fix(update): skip update checks when no Velopack locator is set

With GitHub as the default source, UpdaterService always built an
UpdateManager, which throws unless VelopackApp.Build().Run() has set a
locator. MainApp does, but WinForms test hosts constructing MainForm do
not, so 78 OpenNest.WinForms.Tests failed. Without a locator there is no
installation to update, so the service now stays idle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit d505a50934)

.claude/agents/planner.md

@@ -1,43 +0,0 @@
----
-name: planner
-description: Designs an implementation plan for an OpenNest change before any code is written. Use for features, behavior changes or refactors that touch more than a file or two. Read-only; returns a plan, never edits.
-tools: Read, Grep, Glob, Bash, WebFetch
----
-You plan changes to OpenNest, a .NET 8 CNC-nesting application. You do not edit
-files; you return a plan the main session will implement.
-
-Before planning:
-- Read `AGENTS.md`. Its project map, boundaries and geometry/ownership safeguards
-  are binding constraints on the plan.
-- Read every `docs/` contract that `AGENTS.md` links for the area you touch, and
-  plan within it. If the change must alter a contract, say so and list the doc
-  edits.
-- Find the existing code paths, tests and helpers the change should reuse.
-  Bash is for read-only inspection only (`git log`, `git grep`, `dotnet` listing
-  commands); never build, test, write or change git state.
-
-Return, concisely:
-1. **Goal and approach**: the design in a few sentences, and why over the main
-   alternative if there is a real one.
-2. **Steps**: ordered, each naming the files/types it changes. Mark steps that
-   are independent of each other.
-3. **Boundaries**: which project owns each piece (Core/Engine/IO/Desktop/
-   WinForms/Server), and any boundary the change comes near (IO depends on Core
-   only; Desktop never references WinForms, System.Drawing.Common or Avalonia;
-   Server stays off Engine/IO; WinForms tests stay out of OpenNest.Tests).
-4. **Safeguards at risk**: the specific `AGENTS.md` rules the change could break
-   (tolerances, `PortableMath`, `SpecialLayers.IsMaterial`, undo recording,
-   irregular stock, cutoffs, common lines, posting checks) and how the plan
-   keeps them.
-5. **Verification**: the exact `dotnet test` projects and filters to run; new
-   tests to add; whether the problem-nest corpus applies and with which
-   `OPENNEST_PROBLEM_NESTS_CHECKS` areas (Plan Cutting and engine changes only,
-   never fills, UI, posts or file formats; only the maintainer has it, so when
-   `OPENNEST_PROBLEM_NESTS_SERVER` is unset mark it a maintainer run before
-   merge); whether a nesting engine benchmark
-   applies; whether user help in `ajisaacs/opennest-help` needs updating.
-6. **Open questions**: decisions that are genuinely the user's.
-
-Cite code as `path:line`. Keep the plan to what was asked: no speculative
-extras. Plans are not committed; if one should be saved, it goes under
-`.hermes/plans/`.

.claude/agents/reviewer.md

@@ -1,46 +0,0 @@
----
-name: reviewer
-description: Independently reviews an OpenNest diff for correctness bugs and broken project safeguards. Use after implementing a change, before merging. Give it the branch or commit range, not your conclusions. Read-only; reports findings, never fixes them.
-tools: Read, Grep, Glob, Bash
----
-You review changes to OpenNest, a .NET 8 CNC-nesting application, with fresh
-eyes. You did not write this code; do not assume it is right.
-
-Scope: the diff you are given (default `git diff master...HEAD` plus uncommitted
-changes). Read surrounding code as needed to judge it. Bash is for inspection
-(`git diff`, `git log`, `git grep`) and, when useful, building or running the
-relevant tests; never edit files, commit, stash or switch branches. On Linux,
-build Windows projects with `-p:EnableWindowsTargeting=true` and say that this
-is not Windows runtime verification.
-
-Check, in order:
-1. **Correctness**: logic errors, wrong edge cases, null/empty handling,
-   cancellation and threading, broken invariants, units (angles are radians).
-2. **AGENTS.md safeguards**: read `AGENTS.md` and the `docs/` contracts it links
-   for the touched area, then check the diff against them. Common misses:
-   geometry compared without `Tolerance.Epsilon`; `System.Math` trig in
-   Core/Engine/IO/Data instead of `PortableMath`; marks treated as material
-   instead of `SpecialLayers.IsMaterial`; desktop nest edits without
-   `BeginChange`/`RecordChange`; double quantity accounting around
-   `ObservableList`; anything placed on an irregular (`SheetOutline`) plate
-   outside the Irregular fill; cutoffs applied as preview parts; posting
-   without checks or with a persisted warning bypass; loosened tolerances that
-   hide failures; caches shared across calls or threads.
-3. **Boundaries**: project references (IO -> Core only; Desktop free of
-   WinForms/System.Drawing.Common/Avalonia; Server off Engine/IO; no WinForms in
-   OpenNest.Tests); plug-in engine projects kept out of the solution.
-4. **Tests and docs**: behavior changes have tests that would fail without the
-   change; affected `docs/`, `AGENTS.md` and user help are updated; no design
-   specs, plans, progress notes or benchmark reports are committed; no vendor
-   manual text; no competitor product names.
-5. **Verification owed**: whether the change needs the problem-nest corpus
-   (Plan Cutting and engine changes, limited by area) or an engine benchmark,
-   and whether that was evidently run. Only the maintainer has the corpus: when
-   `OPENNEST_PROBLEM_NESTS_SERVER` is unset, list the needed areas as a
-   maintainer run before merge, not as a finding against the change.
-
-Report only real problems, most severe first. For each: `path:line`, what is
-wrong, a concrete input or state that produces the failure, and how sure you are
-(confirmed by reading/running vs. plausible). Skip style nits that
-`dotnet format` or `.editorconfig` would settle. If nothing survives scrutiny,
-say so plainly; do not pad the list.

.dockerignore

@@ -5,14 +5,6 @@
 !OpenNest.Data/**
 !OpenNest.Core/
 !OpenNest.Core/**
-!OpenNest.Server.Worker/
-!OpenNest.Server.Worker/**
-!OpenNest.Api/
-!OpenNest.Api/**
-!OpenNest.Engine/
-!OpenNest.Engine/**
-!OpenNest.IO/
-!OpenNest.IO/**
 **/bin/**
 **/obj/**
 **/data/**

.gitattributes

@@ -20,6 +20,3 @@
 *.PDF	 diff=astextplain
 *.rtf	 diff=astextplain
 *.RTF	 diff=astextplain
-
-# Container scripts run in Linux images.
-*.sh     text eol=lf

.github/workflows/ci.yml

@@ -19,11 +19,9 @@ jobs:
       matrix:
         project:
           - OpenNest.Tests
-          - OpenNest.Desktop.Tests
           - OpenNest.Engine.Tests
           - OpenNest.IO.Tests
           - OpenNest.Server.Tests
-          - OpenNest.FrontEnd.Tests
     steps:
       - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
         with:
@@ -32,7 +30,7 @@ jobs:
         with:
           dotnet-version: '8.0.x'
       - name: Run ${{ matrix.project }}
-        run: dotnet test "${{ matrix.project }}/${{ matrix.project }}.csproj" -c Release
+        run: dotnet test "${{ matrix.project }}/${{ matrix.project }}.csproj"
 
   synthetic-nests:
     name: Six synthetic Irregular nests
@@ -72,7 +70,7 @@ jobs:
 
   windows-desktop:
     # WinForms tests need a Windows desktop runtime; the Linux job can only
-    # cross-compile them. FrontEnd.Tests also run here, beside the desktop build.
+    # cross-compile them. FrontEnd.Tests run here too, alongside the desktop.
     runs-on: windows-2022
     timeout-minutes: 20
     defaults:

.github/workflows/dev-build.yml

@@ -1,128 +0,0 @@
-name: Development build
-
-# Every master push whose cross-platform tests pass becomes the rolling
-# `dev-build` pre-release: X.Y.Z-dev.N, where X.Y.Z is the minor after the
-# newest release tag and N the commit count. Installed copies take it only
-# with Tools > Options > Include development builds.
-on:
-  workflow_run:
-    workflows: ['Cross-platform tests']
-    types: [completed]
-    branches: [master]
-
-permissions:
-  contents: read
-
-concurrency:
-  group: dev-build
-  cancel-in-progress: true
-
-jobs:
-  package:
-    if: >-
-      github.event.workflow_run.conclusion == 'success' &&
-      github.event.workflow_run.event == 'push' &&
-      github.event.workflow_run.head_repository.full_name == github.repository
-    runs-on: windows-2022
-    timeout-minutes: 30
-    defaults:
-      run:
-        shell: pwsh
-    env:
-      DOTNET_CLI_TELEMETRY_OPTOUT: '1'
-      DOTNET_NOLOGO: '1'
-      SOURCE_SHA: ${{ github.event.workflow_run.head_sha }}
-    outputs:
-      version: ${{ steps.version.outputs.version }}
-    steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          ref: ${{ github.event.workflow_run.head_sha }}
-          fetch-depth: 0
-          persist-credentials: false
-      - uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4
-        with:
-          dotnet-version: '8.0.x'
-      - name: Resolve development version
-        id: version
-        run: |
-          $releases = git tag --list 'v*' | Where-Object { $_ -match '^v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$' } |
-            ForEach-Object { [version]$_.Substring(1) } | Sort-Object
-          if (-not $releases) { throw 'No vX.Y.Z release tag found.' }
-          $latest = @($releases)[-1]
-          $count = (git rev-list --count $env:SOURCE_SHA).Trim()
-          if ($LASTEXITCODE -ne 0) { throw 'Cannot count commits.' }
-          $version = "$($latest.Major).$($latest.Minor + 1).0-dev.$count"
-          Write-Host "Development version $version (after v$latest)"
-          "version=$version" >> $env:GITHUB_OUTPUT
-      - name: Publish and verify Windows package
-        run: ./scripts/Publish-Windows.ps1 -Version ${{ steps.version.outputs.version }}
-      - name: Upload development build
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
-        with:
-          name: OpenNest-dev-build
-          path: |
-            artifacts/*.zip
-            artifacts/*.sha256
-            artifacts/velopack/OpenNest-win-Setup.exe
-            artifacts/velopack/OpenNest-win-Portable.zip
-            artifacts/velopack/*-full.nupkg
-            artifacts/velopack/releases.win.json
-            artifacts/velopack/RELEASES
-          if-no-files-found: error
-          retention-days: 7
-          compression-level: 0
-
-  publish:
-    needs: package
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: write
-      actions: read
-    env:
-      GH_TOKEN: ${{ github.token }}
-      GH_REPO: ${{ github.repository }}
-      SOURCE_SHA: ${{ github.event.workflow_run.head_sha }}
-      VERSION: ${{ needs.package.outputs.version }}
-    steps:
-      - name: Skip if master has moved on
-        id: current
-        run: |
-          head=$(gh api "repos/$GH_REPO/commits/master" --jq .sha)
-          if [ "$head" != "$SOURCE_SHA" ]; then
-            echo "master is at $head; its own run publishes the newer build."
-            echo "skip=true" >> "$GITHUB_OUTPUT"
-          fi
-      - name: Download development build
-        if: steps.current.outputs.skip != 'true'
-        run: gh run download "$GITHUB_RUN_ID" -n OpenNest-dev-build -D dev
-      - name: Verify checksums
-        if: steps.current.outputs.skip != 'true'
-        working-directory: dev
-        run: |
-          sha256sum -c ./*.zip.sha256
-          (cd velopack && sha256sum -c "../OpenNest.v$VERSION.velopack.sha256")
-      - name: Replace the dev-build pre-release
-        if: steps.current.outputs.skip != 'true'
-        working-directory: dev
-        run: |
-          if gh release view dev-build >/dev/null 2>&1; then
-            gh release delete dev-build --cleanup-tag --yes
-          fi
-          cat > notes.md <<EOF
-          Automatic development build of master at $SOURCE_SHA.
-
-          It may contain unfinished features. Installed copies receive it only with
-          **Tools > Options > Include development builds**; full releases are unaffected.
-          EOF
-          gh release create dev-build ./*.zip ./*.sha256 velopack/* \
-            --target "$SOURCE_SHA" --prerelease --latest=false \
-            --title "OpenNest $VERSION (development build, ${SOURCE_SHA:0:8})" --notes-file notes.md
-      - name: Read back the pre-release
-        if: steps.current.outputs.skip != 'true'
-        run: |
-          gh release view dev-build --json isPrerelease,isDraft,tagName,assets \
-            --jq '"prerelease=\(.isPrerelease) draft=\(.isDraft) assets=\(.assets|length)"' | tee readback.txt
-          grep -qx 'prerelease=true draft=false assets=8' readback.txt
-          [ "$(gh api "repos/$GH_REPO/git/ref/tags/dev-build" --jq .object.sha)" = "$SOURCE_SHA" ]

.github/workflows/server-image.yml

@@ -6,10 +6,6 @@ on:
       - 'OpenNest.Server/**'
       - 'OpenNest.Data/**'
       - 'OpenNest.Core/**'
-      - 'OpenNest.Server.Worker/**'
-      - 'OpenNest.Api/**'
-      - 'OpenNest.Engine/**'
-      - 'OpenNest.IO/**'
       - 'OpenNest.Server.Tests/**'
       - 'scripts/Server.Tests/**'
       - 'scripts/Test-ServerContainer.sh'
@@ -25,10 +21,6 @@ on:
       - 'OpenNest.Server/**'
       - 'OpenNest.Data/**'
       - 'OpenNest.Core/**'
-      - 'OpenNest.Server.Worker/**'
-      - 'OpenNest.Api/**'
-      - 'OpenNest.Engine/**'
-      - 'OpenNest.IO/**'
       - 'OpenNest.Server.Tests/**'
       - 'scripts/Server.Tests/**'
       - 'scripts/Test-ServerContainer.sh'

.github/workflows/windows-release.yml

@@ -68,7 +68,7 @@ jobs:
         # mini dump in TestResults, instead of holding the runner until the
         # job timeout.
         run: |
-          foreach ($project in @('OpenNest.Tests', 'OpenNest.Desktop.Tests', 'OpenNest.Engine.Tests', 'OpenNest.IO.Tests', 'OpenNest.Server.Tests', 'OpenNest.WinForms.Tests', 'OpenNest.FrontEnd.Tests')) {
+          foreach ($project in @('OpenNest.Tests', 'OpenNest.Engine.Tests', 'OpenNest.IO.Tests', 'OpenNest.Server.Tests', 'OpenNest.WinForms.Tests', 'OpenNest.FrontEnd.Tests')) {
             dotnet test "$project/$project.csproj" -c Release --no-build --blame-hang-timeout 5m --blame-hang-dump-type mini --logger "trx;LogFileName=$project.trx" --results-directory TestResults
             if ($LASTEXITCODE -ne 0) { throw "$project failed." }
           }

.gitignore

@@ -208,9 +208,7 @@ FakesAssemblies/
 *.db-journal
 
 # Local agent state and temporary planning/progress documents
-# (shared Claude Code agent definitions stay tracked)
+.claude/
-.claude/*
-!.claude/agents/
 /.hermes/plans/
 /.hermes/progress/
 .superpowers/
@@ -227,6 +225,3 @@ OpenNest.Tests/test-config.json
 # Vendor programming manuals: keep reference copies outside source control.
 CINCINNATI LASER PROGRAMMING MANUAL.pdf
 TF5200_programming_manual_en.pdf
-
-# Python bytecode
-__pycache__/

AGENTS.md

@@ -22,30 +22,24 @@ dotnet build OpenNest.sln
 dotnet test OpenNest.Tests/OpenNest.Tests.csproj -c Release
 dotnet test OpenNest.Engine.Tests/OpenNest.Engine.Tests.csproj -c Release
 dotnet test OpenNest.IO.Tests/OpenNest.IO.Tests.csproj -c Release
-dotnet test OpenNest.Desktop.Tests/OpenNest.Desktop.Tests.csproj -c Release
 dotnet test OpenNest.Server.Tests/OpenNest.Server.Tests.csproj -c Release
-dotnet test OpenNest.FrontEnd.Tests/OpenNest.FrontEnd.Tests.csproj -c Release
 
 # Windows runtime tests
 dotnet test OpenNest.WinForms.Tests/OpenNest.WinForms.Tests.csproj
 ```
 
-On Windows, prefer `scripts/Test-Hidden.ps1 <dotnet test args>` for WinForms tests: it runs them on a hidden desktop so no windows appear or take focus; see [hidden-desktop tests](docs/hidden-desktop-tests.md).
+After changing planning, contour preparation or geometry checks, run the [problem-nest corpus](docs/problem-nests.md) (`Category=ProblemNests`, opt-in via `OPENNEST_PROBLEM_NESTS_SERVER`); no plate may rank below its baseline. Keep desktop-dependent tests in `OpenNest.WinForms.Tests`, never add a WinForms reference to `OpenNest.Tests`. Optional CHR fixtures use local `OpenNest.Tests/test-config.json` and skip when absent. On Linux, build Windows projects with `-p:EnableWindowsTargeting=true`; this is not Windows runtime verification. The headless console builds independently with `dotnet build OpenNest.Console/OpenNest.Console.csproj`.
-
-Plan Cutting and nesting-engine changes need the [problem-nest corpus](docs/problem-nests.md) (`Category=ProblemNests`, opt-in via `OPENNEST_PROBLEM_NESTS_SERVER`), which holds every nest that ever caused a problem; engine changes run only its `auto-nest` area. Never run it for fills, UI, posts or file formats. Limit it to the areas the change touches with `OPENNEST_PROBLEM_NESTS_CHECKS` (table in that doc); `part-order` and `entries` plan every nest. No plate may rank below its baseline, and none may join or climb the near-budget list compared with master's run. Keep desktop-dependent tests in `OpenNest.WinForms.Tests`, never add a WinForms reference to `OpenNest.Tests`. Optional CHR fixtures use local `OpenNest.Tests/test-config.json` and skip when absent. On Linux, build Windows projects with `-p:EnableWindowsTargeting=true`; this is not Windows runtime verification. The headless console builds independently with `dotnet build OpenNest.Console/OpenNest.Console.csproj`.
 
 Releases: follow [the release procedure](docs/releasing.md) and `scripts/Publish-Windows.ps1`; workflow artifacts are candidates, not published releases. GitHub (`ajisaacs/OpenNest`) is the primary repository; Gitea is a read-only backup mirror.
 
 ## Project map and boundaries
 
-- `OpenNest.Core`: domain (`Nest -> Plate -> Part -> Drawing -> CNC.Program`), geometry, cutting strategies and diagnostics. Angles are radians; use `Tolerance.Epsilon` for geometry comparisons. `OpenNest.Math` shadows `System.Math`, so qualify the latter, and call `PortableMath` (not `System.Math`) for trig in Core/Engine/IO/Data so layouts match across platforms. `OpenNest.Math` and `OpenNest.Geometry` are Core's bottom layers (Math uses nothing else in OpenNest; Geometry uses Math plus the root types `OffsetSide`, `RotationType`, `PushDirection`, `RelativePosition`, `PerfCounters`, `SpecialLayers`); `CoreLayeringTests` enforces it.
+- `OpenNest.Core`: domain (`Nest -> Plate -> Part -> Drawing -> CNC.Program`), geometry, cutting strategies and diagnostics. Angles are radians; use `Tolerance.Epsilon` for geometry comparisons. `OpenNest.Math` shadows `System.Math`, so qualify the latter.
 - `OpenNest.Engine`: whole-job API in `Jobs/`, interactive proposals via `PlateFillService`, fill strategies, best-fit pairs, packing, sequencing and rapid planning. `INestingEngine.Solve(NestJob)` returns stock IDs/poses; boundary adapters map drawings and materialize results. `NestJobRunner` validates its candidates before committing demand/stock accounting. Do not assume arbitrary plug-in output or interactive paths received that validation. Job identity is reference-based, not drawing-name-based.
 - Built-in whole-job engines live in `OpenNest.Engine/NestingEngines/<Name>/`, named for the jobs they suit; see [nesting engines](docs/nesting-engines.md). A change must beat that engine's current benchmark result with every layout valid. External plug-ins implement `INestingEngine` with a public parameterless constructor and load from `Engines/` beside the host; keep their projects out of this solution.
-- `OpenNest.IO`: ACadSharp and SVG import/export and ZIP-based `.nest` persistence; depends on Core only (an IO.Tests guard enforces it). Best fits persist only when callers pass `BestFitCacheStore.Shared` as `NestReader`/`NestWriter.BestFitStore`. All DXF-to-Drawing conversion goes through `CadImporter`: `Import` + `BuildDrawing` for editable/reporting flows, `ImportDrawing` for headless callers. Preserve source offsets, entity IDs, suppressed entities and bends. Bend repair is opt-in, requires explicit source units and may not alter cut geometry or unrelated marks.
+- `OpenNest.IO`: ACadSharp import/export and ZIP-based `.nest` persistence; depends on Core only (an IO.Tests guard enforces it). Best fits persist only when callers pass `BestFitCacheStore.Shared` as `NestReader`/`NestWriter.BestFitStore`. All DXF-to-Drawing conversion goes through `CadImporter`: `Import` + `BuildDrawing` for editable/reporting flows, `ImportDrawing` for headless callers. Preserve source offsets, entity IDs, suppressed entities and bends. Bend repair is opt-in, requires explicit source units and may not alter cut geometry or unrelated marks.
-- `OpenNest`: WinForms UI (`Forms/`, `Controls/PlateView`, `Actions/`). `OpenNest.Data` holds cross-platform persistence; new-nest defaults live in `%APPDATA%\OpenNest\defaults.json` (in Database mode, the server's shared copy once it holds one). WinForms `Properties.Settings` persist to `%APPDATA%\OpenNest\user-settings.json` through `AppDataSettingsProvider`, never inside the Velopack install folder; `OpenNest.WinForms.Tests` redirects them to a temp file, so a test run never writes the user's settings. Posts live in `Posts/OpenNest.Posts.<Name>/` and deploy to each desktop app's output `Posts/` directory (WinForms and Avalonia). Desktop nest edits go through `BeginChange`/`RecordChange`; see [undo and redo](docs/undo-redo.md).
+- `OpenNest`: WinForms UI (`Forms/`, `Controls/PlateView`, `Actions/`). `OpenNest.Data` holds cross-platform persistence; new-nest defaults live in `%APPDATA%\OpenNest\defaults.json` (in Database mode, the server's shared copy once it holds one). Posts live in `Posts/OpenNest.Posts.<Name>/` and deploy to the desktop output's `Posts/` directory. Desktop nest edits go through `BeginChange`/`RecordChange`; see [undo and redo](docs/undo-redo.md).
-- `OpenNest.Desktop` (net8.0): toolkit-neutral desktop logic shared by the WinForms app and `OpenNest.Avalonia`, the cross-platform desktop in progress. It must not reference WinForms/WindowsDesktop, `System.Drawing.Common` or Avalonia (`OpenNest.Desktop.Tests` guards this, including transitive packages); put toolkit-specific rendering, dialogs and settings behind adapters in the front ends.
+- `OpenNest.Console`, `OpenNest.Mcp`, `OpenNest.Api`: front ends; `OpenNest.Benchmark`: whole-job engine comparisons; `OpenNest.Gpu`: GPU evaluators; `OpenNest.Training`: ML data collection. Benchmark timing comparisons require `--parallel 1`; validate layouts and fulfillment, not just elapsed time.
-- `OpenNest.Server`: nest storage HTTP service, kept off Engine and IO. `OpenNest.Server.Worker`: the server nesting worker, shipped in the same image.
-- `OpenNest.Console`, `OpenNest.Mcp`, `OpenNest.Api`: front ends; `OpenNest.Benchmark`: whole-job engine comparisons; `OpenNest.Gpu`: GPU evaluators; `OpenNest.Training`: ML data collection and the Python sketch-search prototype (`sketch-search/README.md`). Benchmark timing comparisons require `--parallel 1`; validate layouts and fulfillment, not just elapsed time.
 
 ## Geometry and ownership safeguards
 
@@ -54,35 +48,28 @@ Releases: follow [the release procedure](docs/releasing.md) and `scripts/Publish
 - `FillLinear` geometry caches are per public call, keyed by `Program` reference identity; never share them across calls/threads. `PartOverlapChecker` is per check; parts/programs must not mutate during its lifetime.
 - `FillScore` ranks count, utilization, compactness; exact ties keep the current layout. Custom comparers remain authoritative. Preserve extents' negative/nonfinite-input fallback, pair preparation and adjusted-column overlap checks. Do not remove bounds recomputations without threshold/rounding characterization.
 - `ObservableList` events own drawing/plate quantity tracking; avoid double accounting. Cutoff parts are excluded from quantity, utilization and overlap checks.
-- `Plate.Outline`/`NestPlateStock.Outline` (`SheetOutline`) make a sheet irregular; `Size` stays its bounding box. Only Irregular fills it (`PackBoundary` eroded by the largest edge spacing); every other engine and fill strategy must place nothing on it, validation must reject parts outside it or over its obstacles, and automatic cut-offs refuse it. See [irregular stock](docs/irregular-stock.md).
 - Cutoffs persist as definitions on `Plate.CutOffs`; apply through `RegenerateCutOffs`, never preview parts. Preserve sequence positions. Batch planning must finish before mutation and roll back on failure. Use `PlateSequencing.Apply` for automatic cutoff dependencies, with nominal spans/reference identity rather than trimmed geometry/names.
 - A cutoff starts only at the origin-side edge: stock can be oversize, so the far edge is unknown. Only a head-locked overcut (`CutOff.HeadLockOvercut`, `HeadHeightLock` markers) may start its far-edge segment there; posts refuse it without lock codes.
 - Fixed emissions (locked programs, drawing-pinned contours) are accepted as given: their violations warn on an UNVERIFIED proposal and never steer the search, while every planner-chosen motion stays strict. Plates without them must keep the `PlanningCharacterizationTests` digests.
-- A `HeadRaise` marker (a rapid made head-up over cut parts) is the safest-route fallback's last resort, added only after the strict search fails; the strict search never marks a rapid. The one designed raise is the rapid out of a cutout's slug after its lead-out, marked at emission (see the cutting planner doc); no lead-out or an overcut keeps the head down. Every post must raise before a marked rapid or refuse the nest.
 - An empty diagnostic is not a clear result unless `IsComplete`. Posting must run checks before writing CNC output; warnings require explicit per-attempt consent, never a persisted bypass. Keep inputs stable through analysis/cancellation.
 - Preserve symbolic G-code variable definitions/references in file round trips. Keep training bitmaps by default; inference checks predictor availability before scalar-only extraction.
 
 Read the relevant contract before changing its behavior:
 
 - [Nest file format](docs/nest-file-format.md)
-- [SVG import and export](docs/svg-import-export.md): SVG numbers are not drawing units; import never guesses a scale
-- [Irregular stock](docs/irregular-stock.md): outlined sheets, what honors the outline and what refuses it
 - [Directional slides](docs/geometry/directional-slides.md) and [pair-spacing limits](docs/geometry/pair-spacing.md)
-- [Lead-in placement](docs/geometry/lead-in-placement.md) (including the planner's eroded pierce for cutouts too small for their lead-in and the stop at a feature's center line) and [pierce zones](docs/geometry/pierce-zone.md): opt-in `PierceDiameter` clearance, the hole pole fallback and the planner's perimeter scrap fallback
+- [Lead-in placement](docs/geometry/lead-in-placement.md) (including the planner's eroded pierce for cutouts too small for their lead-in) and [pierce zones](docs/geometry/pierce-zone.md): opt-in `PierceDiameter` clearance, the hole pole fallback and the planner's perimeter scrap fallback
 - [Breakoffs](docs/breakoffs.md): tabbed scrap; `Break`-layer open cuts that are cut but are not material
 - [Tabbed cutouts](docs/tabbed-cutouts.md): holes cut in pieces around `Tab`-layer spans that are material but never cut; nesting reads material through `NestingMaterial.ForNesting`, so nothing nests in them
-- [Dimensions](docs/dimensions.md): CAD Converter annotations that store placement only, are measured from the cut geometry when shown and never affect the program
+- [Support tabs](docs/support-tabs.md): the nest's support grid, the center-of-gravity check, and Plan Cutting's tab placement for parts the grid cannot hold level
-- [Common-line cutting](docs/common-line-cutting.md): parts one kerf apart in `Plate.CommonLines` share an edge; spans are derived, never stored, and spacing checks hold group members to the kerf. Plan Cutting cuts each shared span once (the owner, cut first, starts its compensated outside on the common line; partners cut only their remainders) unless the plate is set to cut them twice; only posts implementing `ICommonLinePostProcessor` (CI Fiber) may write it, others refuse. Machine trial pending. Auto Nest and Fill Area pair `AllowCommonLine` drawings at the nest's `CommonLineUsage` (Off by default, byte-identical to no common lines); `NestLayoutCheck` exempts only explicit result groups
-- [Support tabs](docs/support-tabs.md): the nest's support grid, the center-of-gravity check, Plan Cutting's tab placement for parts the grid cannot hold level, and its opt-in slicing of slugs the grid cannot hold level
 - [Material-overlap diagnostics](docs/geometry/visual-overlap-check.md)
 - [Automatic cutoffs and sequencing](docs/automatic-scrap-cutoffs.md)
 - [Pre-post verification](docs/post-verification.md)
-- [Machine cutting defaults](docs/machine-cutting-defaults.md): the nest's machine supplies leads, kerf, tabs, pierce and cut-off settings per material and thickness; the Cutting Parameters dialog saves to that thickness
+- [Machine cutting defaults](docs/machine-cutting-defaults.md): the nest's machine supplies leads, kerf and cut-off settings for plates without their own parameters
 - [Shared settings](docs/shared-settings.md): in Database mode machines, post settings, clamps and nest defaults come from the server once it holds them; offline uses the last copy read, read-only
-- [Server nesting](docs/server-nesting.md): Database-mode Auto Nest queued to the server's worker container (`OPENNEST_ROLE=worker`), one job at a time with no time limit, streaming progress and the best plan so far over SSE; the desktop replays the recorded engine answers to validate and bind locally. My Server Jobs reopens results in later sessions, and each result is kept at most once (`If-Match` Keep). The HTTP server stays off Engine/IO
 - [Cut-time estimates](docs/cut-time-estimates.md): simulator/Calculate Cut Time acceleration planner and placeholder machine limits
 - [Cincinnati CL](docs/cincinnati-post-output.md) and [CI Fiber](docs/cincinnati-ci-fiber-post-output.md)
 - [Fill verification](docs/performance/fill-verification.md): opt-in benchmarks, frozen oracles, Debug-only counters and predictor initialization. Zero Release counters do not prove work removal.
-- [Desktop auto-update](docs/auto-update.md): GitHub Releases by default, opt-in rolling `dev-build` pre-release from green master pushes, the nest server's `/updates` mirror first in Database mode (GitHub fallback), `UpdateFeedUrl` for a self-hosted feed, release Velopack assets and `Deploy-OpenNest.ps1`.
+- [Desktop auto-update](docs/auto-update.md): GitHub Releases by default, `UpdateFeedUrl` for a self-hosted feed, release Velopack assets and `Deploy-OpenNest.ps1`.
 - [Undo and Redo](docs/undo-redo.md): whole-nest history, the recording rule, what a restore rebuilds and what is excluded.
-- [Desktop help](docs/desktop-help.md): WebView2 help window, topic IDs and the pinned help release both packaging scripts install.
+- [Desktop help](docs/desktop-help.md): WebView2 help window, F1 topic IDs and the pinned help release both packaging scripts install.

OpenNest.Api/NestJobPackage.cs

@@ -1,102 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.IO.Compression;
-using System.Linq;
-using System.Text;
-using OpenNest.Engine;
-using OpenNest.Engine.Jobs;
-using OpenNest.Engine.Jobs.Remote;
-using OpenNest.IO;
-
-namespace OpenNest.Api;
-
-/// <summary>
-/// A whole-job nest request as one upload for the nest server: a ZIP holding
-/// <c>job.json</c> (<see cref="NestJobDocument"/>) and <c>drawings.nest</c>, a nest archive of
-/// exactly the items' drawings in the order the document names them. Drawings travel as the
-/// nest file format stores them, so the server nests what the client has, edits included.
-/// </summary>
-public static class NestJobPackage
-{
-    public const string JobEntry = "job.json";
-    public const string DrawingsEntry = "drawings.nest";
-
-    public static byte[] Write(NestPipelineRequest request, Units units = Units.Inches)
-    {
-        ArgumentNullException.ThrowIfNull(request);
-        ArgumentNullException.ThrowIfNull(request.Items);
-        var drawings = new List<Drawing>();
-        foreach (var item in request.Items)
-        {
-            if (item?.Drawing != null && !drawings.Any(d => ReferenceEquals(d, item.Drawing)))
-                drawings.Add(item.Drawing);
-        }
-        var document = NestJobDocument.From(request, drawings);
-
-        // A throwaway nest holds the drawings only; the caller's nest is never written.
-        var nest = new Nest { Units = units };
-        foreach (var drawing in drawings)
-            nest.Drawings.Add(drawing);
-
-        using var buffer = new MemoryStream();
-        using (var zip = new ZipArchive(buffer, ZipArchiveMode.Create, leaveOpen: true))
-        {
-            using (var writer = new StreamWriter(zip.CreateEntry(JobEntry).Open(), new UTF8Encoding(false)))
-                writer.Write(document.ToJson());
-            using var archive = zip.CreateEntry(DrawingsEntry, CompressionLevel.NoCompression).Open();
-            new NestWriter(nest).Write(archive);
-        }
-        return buffer.ToArray();
-    }
-
-    /// <summary>
-    /// The package's <c>job.json</c> alone, without reading its drawings: a desktop reviewing the
-    /// job in a later session binds it to its own drawings instead
-    /// (<see cref="RemoteNestSubmission.Reopen"/>). Throws <see cref="FormatException"/> when it is not a package.
-    /// </summary>
-    public static NestJobDocument ReadDocument(byte[] package)
-    {
-        ArgumentNullException.ThrowIfNull(package);
-        try
-        {
-            using var zip = new ZipArchive(new MemoryStream(package, writable: false), ZipArchiveMode.Read);
-            var jobEntry = zip.GetEntry(JobEntry) ?? throw new FormatException($"The nest job has no {JobEntry}.");
-            using var reader = new StreamReader(jobEntry.Open(), Encoding.UTF8);
-            return NestJobDocument.FromJson(reader.ReadToEnd());
-        }
-        catch (InvalidDataException ex)
-        {
-            throw new FormatException("The nest job is not a readable ZIP package.", ex);
-        }
-    }
-
-    /// <summary>Reads a package back into a request; throws <see cref="FormatException"/> when it is not one.</summary>
-    public static NestPipelineRequest Read(byte[] package)
-    {
-        ArgumentNullException.ThrowIfNull(package);
-        try
-        {
-            using var zip = new ZipArchive(new MemoryStream(package, writable: false), ZipArchiveMode.Read);
-            var jobEntry = zip.GetEntry(JobEntry) ?? throw new FormatException($"The nest job has no {JobEntry}.");
-            var drawingsEntry = zip.GetEntry(DrawingsEntry) ?? throw new FormatException($"The nest job has no {DrawingsEntry}.");
-
-            string json;
-            using (var reader = new StreamReader(jobEntry.Open(), Encoding.UTF8))
-                json = reader.ReadToEnd();
-            var document = NestJobDocument.FromJson(json);
-
-            // NestReader needs a seekable stream.
-            using var archive = new MemoryStream();
-            using (var entry = drawingsEntry.Open())
-                entry.CopyTo(archive);
-            archive.Position = 0;
-            var nest = new NestReader(archive).Read();
-            return document.ToRequest(nest.Drawings.ToList());
-        }
-        catch (InvalidDataException ex)
-        {
-            throw new FormatException("The nest job is not a readable ZIP package.", ex);
-        }
-    }
-}

OpenNest.Api/NestRequestPart.cs

@@ -7,6 +7,5 @@ public class NestRequestPart
     public string DxfPath { get; init; }
     public int Quantity { get; init; } = 1;
     public bool AllowRotation { get; init; } = true;
-    /// <summary>Nesting order: higher numbers nest first.</summary>
     public int Priority { get; init; } = 0;
 }

OpenNest.Avalonia/App.axaml.cs

@@ -15,23 +15,13 @@ namespace OpenNest.Avalonia
                 var window = new MainWindow();
                 desktop.MainWindow = window;
                 var args = desktop.Args ?? System.Array.Empty<string>();
-                // Each nest path before the first --option opens in its own tab; the last is shown.
+                if (args.Length > 0)
-                foreach (var path in args)
+                    window.OpenNest(args[0]);
-                {
+                // --snapshot <png> [plate]: render the window to an image and exit, for checking the drawing.
-                    if (path.StartsWith("--"))
-                        break;
-                    window.OpenNest(path);
-                }
-                // --auto-nest: run Auto Nest on the opened nest (with --snapshot, before rendering).
-                if (System.Array.IndexOf(args, "--auto-nest") >= 0)
-                    window.AutoNestOnOpen();
-                // --snapshot <png> [plate]: render the window to an image (status line in <png>.txt) and exit.
                 var snapshot = System.Array.IndexOf(args, "--snapshot");
                 if (snapshot >= 0 && snapshot + 1 < args.Length)
                     window.SaveSnapshotAndClose(args[snapshot + 1],
                         snapshot + 2 < args.Length && int.TryParse(args[snapshot + 2], out var plate) ? plate : 1);
-                else
-                    window.RememberPlacement();
             }
 
             base.OnFrameworkInitializationCompleted();

OpenNest.Avalonia/ConfirmDialog.cs

@@ -1,72 +0,0 @@
-using System.Threading.Tasks;
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Layout;
-using Avalonia.Media;
-
-namespace OpenNest.Avalonia
-{
-    /// <summary>
-    /// A message with a row of buttons ending in Cancel (OK for a plain message). That last
-    /// button is the default and Esc, so a stray Enter never discards work, and closing the
-    /// dialog counts as it.
-    /// </summary>
-    internal sealed class ConfirmDialog : Window
-    {
-        private ConfirmDialog(string title, string message, string[] choices, string cancelText)
-        {
-            Title = title;
-            Width = 460;
-            SizeToContent = SizeToContent.Height;
-            CanResize = false;
-            WindowStartupLocation = WindowStartupLocation.CenterOwner;
-
-            var buttons = new StackPanel
-            {
-                Orientation = Orientation.Horizontal,
-                HorizontalAlignment = HorizontalAlignment.Right,
-                Spacing = 8,
-            };
-            for (var i = 0; i < choices.Length; i++)
-            {
-                var index = i;
-                var choice = new Button { Content = choices[i] };
-                choice.Click += (_, _) => Close(index);
-                buttons.Children.Add(choice);
-            }
-            var cancel = new Button { Content = cancelText, IsDefault = true, IsCancel = true };
-            cancel.Click += (_, _) => Close(null);
-            buttons.Children.Add(cancel);
-
-            var panel = new StackPanel { Margin = new Thickness(18), Spacing = 18 };
-            // A long message (many load warnings) scrolls rather than pushing the buttons away.
-            panel.Children.Add(new ScrollViewer
-            {
-                MaxHeight = 420,
-                Content = new TextBlock { Text = message, TextWrapping = TextWrapping.Wrap },
-            });
-            panel.Children.Add(buttons);
-            Content = panel;
-            Opened += (_, _) => cancel.Focus();
-        }
-
-        /// <summary>True when the user chose <paramref name="confirmText"/>.</summary>
-        public static async Task<bool> AskAsync(
-            Window owner, string title, string message, string confirmText) =>
-            await ChooseAsync(owner, title, message, confirmText) == 0;
-
-        /// <summary>
-        /// The index of the choice the user clicked, or -1 for Cancel (also Esc, Enter and
-        /// closing the dialog).
-        /// </summary>
-        public static async Task<int> ChooseAsync(
-            Window owner, string title, string message, params string[] choices) =>
-            await new ConfirmDialog(title, message, choices, "Cancel")
-                .ShowDialog<int?>(owner) ?? -1;
-
-        /// <summary>A message with only an OK button.</summary>
-        public static Task ShowAsync(Window owner, string title, string message) =>
-            new ConfirmDialog(title, message, System.Array.Empty<string>(), "OK")
-                .ShowDialog<int?>(owner);
-    }
-}

OpenNest.Avalonia/Controls/PlateCanvas.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
 using Avalonia;
 using Avalonia.Input;
 using Avalonia.Media;
@@ -10,10 +8,7 @@ using Avalonia.Rendering.SceneGraph;
 using Avalonia.Skia;
 using OpenNest.Avalonia.Rendering;
 using OpenNest.CNC;
-using OpenNest.CommonLines;
-using OpenNest.Desktop.Rendering;
 using OpenNest.Geometry;
-using OpenNest.Support;
 using SkiaSharp;
 using Control = Avalonia.Controls.Control;
 using Vector = OpenNest.Geometry.Vector;
@@ -21,30 +16,29 @@ using Vector = OpenNest.Geometry.Vector;
 namespace OpenNest.Avalonia.Controls
 {
     /// <summary>
-    /// Draws one plate with Skia as the WinForms plate view does, in the colours of
+    /// Draws one plate with Skia: pans with a left or middle drag, zooms at the cursor with the
-    /// <see cref="Scheme"/>: the sheet (or irregular outline), edge spacing, filled parts with their
+    /// wheel, fits on a double click, and highlights the part under the cursor.
-    /// numbers, cut-offs, clamps, common lines and the View toggles in <see cref="Options"/>. Pans
-    /// with a left or middle drag, zooms at the cursor with the wheel, fits on a double click, and
-    /// highlights the part under the cursor.
     /// </summary>
     public sealed class PlateCanvas : Control
     {
-        // Paths are built once per part pose and only read afterwards, so the render thread may draw
+        private static readonly SKColor BackgroundColor = new(169, 169, 169);
-        // them while the UI thread builds others.
+        private static readonly SKColor PlateFillColor = new(245, 245, 245);
-        private readonly Dictionary<Part, PartPaths> paths = new();
+        private static readonly SKColor PlateOutlineColor = new(128, 128, 128);
-        private readonly Dictionary<Drawing, (CNC.Program Program, double Rotation, Vector Point)> labelPoints = new();
+        private static readonly SKColor EdgeSpacingColor = new(180, 180, 180);
-        private readonly ConditionalWeakTable<Part, OffsetEntry> offsets = new();
+        private static readonly SKColor LeadColor = new(255, 0, 0);
-        private readonly SupportAnalysisCache supports = new();
+        private static readonly SKColor EtchColor = new(0, 150, 60);
-        private readonly Dictionary<CommonLineGroup, (string State, CommonLineCheck Check)> commonLineChecks = new();
+        private static readonly SKColor SelectedColor = new(150, 200, 255, 90 * 255 / 100);
-        private readonly ViewTransform view = new();
+
+        // Paths are built once per program and only read afterwards, so the render thread may draw
+        // them while the UI thread builds others. Keyed by reference: a rotation replaces the program.
+        private readonly Dictionary<CNC.Program, ProgramPaths> paths = new();
 
         private Plate plate;
+        private double scale = 1;
+        private Point origin;
         private Point? dragStart;
         private bool fitPending = true;
 
-        private sealed record OffsetEntry(CNC.Program Program, double Rotation, double Spacing, double Tolerance,
-            SKPath Path);
-
         public Plate Plate
         {
             get => plate;
@@ -54,17 +48,10 @@ namespace OpenNest.Avalonia.Controls
                 HoveredPart = null;
                 SelectedPart = null;
                 fitPending = true;
-                TrimCache();
                 InvalidateVisual();
             }
         }
 
-        /// <summary>The colours drawn with: the application's active scheme unless set.</summary>
-        public ColorScheme Scheme { get; set; } = ColorScheme.Default;
-
-        /// <summary>The View menu toggles this view draws with.</summary>
-        public PlateViewOptions Options { get; set; } = new();
-
         public Part HoveredPart { get; private set; }
 
         public Part SelectedPart { get; private set; }
@@ -72,12 +59,6 @@ namespace OpenNest.Avalonia.Controls
         /// <summary>The cursor in plate coordinates, or null when it is outside the view.</summary>
         public Vector? CursorWorld { get; private set; }
 
-        /// <summary>Pixels per drawing unit.</summary>
-        public double Zoom => view.Scale;
-
-        /// <summary>The view's world/screen mapping.</summary>
-        public ViewTransform View => view;
-
         public event EventHandler ViewChanged;
 
         public PlateCanvas()
@@ -86,29 +67,7 @@ namespace OpenNest.Avalonia.Controls
             Focusable = true;
         }
 
-        public void ClearCache()
+        public void ClearCache() => paths.Clear();
-        {
-            paths.Clear();
-            labelPoints.Clear();
-            commonLineChecks.Clear();
-        }
-
-        // Keeps only the shown plate's parts, so closed plates do not hold their paths.
-        private void TrimCache()
-        {
-            if (plate == null)
-            {
-                paths.Clear();
-                labelPoints.Clear();
-                return;
-            }
-            var shown = new HashSet<Part>(plate.Parts);
-            foreach (var stale in paths.Keys.Where(part => !shown.Contains(part)).ToList())
-                paths.Remove(stale);
-            var drawings = new HashSet<Drawing>(plate.Parts.Select(part => part.BaseDrawing));
-            foreach (var stale in labelPoints.Keys.Where(drawing => !drawings.Contains(drawing)).ToList())
-                labelPoints.Remove(stale);
-        }
 
         public void ZoomToFit()
         {
@@ -123,195 +82,82 @@ namespace OpenNest.Avalonia.Controls
         {
             if (plate == null || Bounds.Width <= 0 || Bounds.Height <= 0)
                 return false;
-            view.Resize(Bounds.Width, Bounds.Height);
+            var extents = PlateRect(plate);
-            if (!view.ZoomToArea(plate.BoundingBox(true)))
+            foreach (var part in plate.Parts)
-                return false;
+                extents = Union(extents, part.BoundingBox);
+            const double margin = 20;
+            var sx = (Bounds.Width - 2 * margin) / System.Math.Max(extents.Length, 1e-6);
+            var sy = (Bounds.Height - 2 * margin) / System.Math.Max(extents.Width, 1e-6);
+            scale = System.Math.Min(sx, sy);
+            origin = new Point(
+                Bounds.Width / 2 - (extents.Left + extents.Length / 2) * scale,
+                Bounds.Height / 2 + (extents.Bottom + extents.Width / 2) * scale);
             fitPending = false;
             return true;
         }
 
-        private Vector ToWorld(Point p) => view.ScreenToWorld(p.X, p.Y);
+        public double Zoom => scale;
+
+        private Vector ToWorld(Point p) => new((p.X - origin.X) / scale, (origin.Y - p.Y) / scale);
 
         private SKMatrix WorldMatrix =>
-            new((float)view.Scale, 0, (float)view.OriginX, 0, (float)-view.Scale, (float)view.OriginY, 0, 0, 1);
+            new((float)scale, 0, (float)origin.X, 0, (float)-scale, (float)origin.Y, 0, 0, 1);
 
-        private PartPaths PathsFor(Part part)
+        private static Box PlateRect(Plate plate)
         {
-            if (!paths.TryGetValue(part, out var result) || !result.Geometry.IsCurrentFor(part))
+            var left = plate.Quadrant is 2 or 3 ? -plate.Size.Length : 0;
-                paths[part] = result = PartPaths.Build(part);
+            var bottom = plate.Quadrant is 3 or 4 ? -plate.Size.Width : 0;
+            return new Box(left, bottom, plate.Size.Length, plate.Size.Width);
+        }
+
+        private static Box Union(Box a, Box b)
+        {
+            var left = System.Math.Min(a.Left, b.Left);
+            var bottom = System.Math.Min(a.Bottom, b.Bottom);
+            return new Box(left, bottom,
+                System.Math.Max(a.Right, b.Right) - left, System.Math.Max(a.Top, b.Top) - bottom);
+        }
+
+        private ProgramPaths PathsFor(Part part)
+        {
+            if (!paths.TryGetValue(part.Program, out var result))
+                paths[part.Program] = result = ProgramPaths.Build(part.Program);
             return result;
         }
 
-        private Vector LabelPoint(Part part)
-        {
-            if (PartLabels.CutOffSegmentPoint(part) is { } cutOff)
-                return cutOff;
-            var drawing = part.BaseDrawing;
-            if (!labelPoints.TryGetValue(drawing, out var cached)
-                || !ReferenceEquals(cached.Program, drawing.Program) || cached.Rotation != drawing.Program.Rotation)
-            {
-                cached = (drawing.Program, drawing.Program.Rotation, PartLabels.LabelPoint(drawing));
-                labelPoints[drawing] = cached;
-            }
-            return PartLabels.Place(part, cached.Point);
-        }
-
-        private SKPath OffsetFor(Part part, double spacing, double tolerance)
-        {
-            if (offsets.TryGetValue(part, out var entry) && ReferenceEquals(entry.Program, part.Program)
-                && entry.Rotation == part.Rotation && entry.Spacing == spacing && entry.Tolerance == tolerance)
-                return entry.Path;
-            var polygons = PlateOverlays.OffsetOutline(part, spacing, tolerance);
-            var path = SkiaFigures.Polygons(polygons.Select(p => (IReadOnlyList<Vector>)p.Vertices));
-            offsets.AddOrUpdate(part, new OffsetEntry(part.Program, part.Rotation, spacing, tolerance, path));
-            return path;
-        }
-
         public override void Render(DrawingContext context)
         {
             // A redraw may not be requested during a render, so tell listeners afterwards.
             if (fitPending && Fit())
                 global::Avalonia.Threading.Dispatcher.UIThread.Post(() => ViewChanged?.Invoke(this, EventArgs.Empty));
-            if (Bounds.Width > 0 && Bounds.Height > 0)
-                view.Resize(Bounds.Width, Bounds.Height);
 
-            var scene = new Scene
+            var items = new List<PartItem>();
-            {
-                Bounds = new Rect(Bounds.Size),
-                Palette = SkiaSchemePalette.For(Scheme ?? ColorScheme.Default),
-                Matrix = WorldMatrix,
-                Scale = view.Scale,
-                DrawOrigin = Options.DrawOrigin,
-            };
             if (plate != null)
-                BuildScene(scene);
-            context.Custom(new PlateDrawOperation(scene));
-        }
-
-        private void BuildScene(Scene scene)
-        {
-            var options = Options;
-            var visible = view.VisibleWorld();
-            scene.Sheet = PlateOverlays.Sheet(plate);
-            if (plate.Outline is { } outline)
             {
-                scene.SheetOutline = SkiaFigures.Polygons(new[] { PlateOverlays.PlaceOutline(plate, outline.Points) }
+                for (var i = 0; i < plate.Parts.Count; i++)
-                    .Concat(outline.Obstacles.Select(o => PlateOverlays.PlaceOutline(plate, o))));
-                scene.Obstacles = outline.Obstacles.Count == 0 ? null
-                    : SkiaFigures.Polygons(outline.Obstacles.Select(o => PlateOverlays.PlaceOutline(plate, o)));
-                var usable = PlateOverlays.UsableOutline(plate);
-                scene.Usable = usable.Count == 0 ? null : SkiaFigures.Polygons(usable);
-            }
-            else
-            {
-                var edge = PlateOverlays.EdgeSpacing(plate);
-                // As WinForms: the edge-spacing line is left out while it surrounds the whole view.
-                if (!Contains(edge, visible))
-                    scene.EdgeSpacing = edge;
-            }
-
-            var palette = scene.Palette;
-            for (var i = 0; i < plate.Parts.Count; i++)
-            {
-                var part = plate.Parts[i];
-                var partPaths = PathsFor(part);
-                var bounds = partPaths.StrokeBounds;
-                var placed = bounds == null ? null : bounds.Translate(part.Location.X, part.Location.Y);
-                if (placed == null || !Intersects(placed, visible))
-                    continue;
-                var color = ToSkColor(part.BaseDrawing.Color);
-                scene.Parts.Add(new PartItem(partPaths, part.Location, placed, color, palette.PartOutline(color),
-                    (i + 1).ToString(), LabelPoint(part), ReferenceEquals(part, SelectedPart),
-                    ReferenceEquals(part, HoveredPart), part.BaseDrawing.IsCutOff));
-            }
-
-            if (options.DrawOffset && plate.PartSpacing > 0)
-            {
-                foreach (var part in plate.Parts)
-                    scene.Offsets.Add((OffsetFor(part, plate.PartSpacing, options.OffsetTolerance), part.Location));
-            }
-            if (options.DrawBounds && SelectedPart != null)
-                scene.SelectionBounds = PlateOverlays.SelectionBounds(new[] { SelectedPart });
-            if (options.DrawRapid)
-                scene.Rapids = PlateOverlays.Rapids(plate);
-            if (options.DrawPiercePoints)
-                scene.PiercePoints = PlateOverlays.PiercePoints(plate);
-            if (options.DrawCutDirection)
-                scene.Arrows = PlateOverlays.CutDirection(plate, view.LengthToWorld(60));
-
-            scene.Clamps = PlateOverlays.Clamps(plate);
-            scene.RemovedClamps = PlateOverlays.RemovedClamps(plate);
-            scene.CutOffStrokes = PlateOverlays.CutOffStrokes(plate);
-            BuildCommonLines(scene);
-            if (options.DrawSupport)
-                BuildSupport(scene);
-        }
-
-        private void BuildCommonLines(Scene scene)
-        {
-            if (plate.CommonLines is not { Count: > 0 } groups)
-            {
-                commonLineChecks.Clear();
-                return;
-            }
-            foreach (var stale in commonLineChecks.Keys.Where(group => !groups.Contains(group)).ToList())
-                commonLineChecks.Remove(stale);
-            foreach (var group in groups)
-            {
-                var state = string.Join(";", group.Members.Select(m =>
-                    $"{m.Location.X:R},{m.Location.Y:R},{m.Rotation:R},{RuntimeHelpers.GetHashCode(m.BaseDrawing.Program)}"));
-                if (!commonLineChecks.TryGetValue(group, out var cached) || cached.State != state)
                 {
-                    cached = (state, CommonLineGeometry.Check(group));
+                    var part = plate.Parts[i];
-                    commonLineChecks[group] = cached;
+                    items.Add(new PartItem(PathsFor(part), part.Location, part.BoundingBox,
-                }
+                        ToSkColor(part.BaseDrawing.Color), (i + 1).ToString(),
-                foreach (var path in CommonLineGeometry.Paths(cached.Check.Spans, group.Kerf))
+                        ReferenceEquals(part, SelectedPart), ReferenceEquals(part, HoveredPart),
-                    scene.CommonLines.Add(path.Points);
+                        part.BaseDrawing.IsCutOff, part.HasManualLeadIns));
-                foreach (var problem in cached.Check.Problems)
-                {
-                    // A copy: moving the part changes its box in place while the render thread draws.
-                    var box = problem.Part.BoundingBox;
-                    scene.CommonLineProblems.Add(new Box(box.X, box.Y, box.Length, box.Width));
                 }
             }
+
+            context.Custom(new PlateDrawOperation(new Rect(Bounds.Size), plate == null ? null : PlateRect(plate),
+                plate?.EdgeSpacing, WorldMatrix, items));
         }
 
-        private void BuildSupport(Scene scene)
-        {
-            if (plate.SupportBed is not { } bed)
-                return;
-            // Grid points and slats only while they are at least 6 pixels apart on screen.
-            const double minimumSpacing = 6;
-            if (bed is SupportGrid grid
-                && view.LengthToScreen(System.Math.Min(grid.PitchX, grid.PitchY)) >= minimumSpacing)
-                scene.GridPoints = grid.PointsIn(scene.Sheet, plate.Quadrant);
-            else if (bed is SupportSlats slats && view.LengthToScreen(slats.Pitch) >= minimumSpacing)
-                scene.Slats = slats.SlatsIn(scene.Sheet, plate.Quadrant);
-
-            var clearance = PlateOverlays.SupportClearance(plate);
-            foreach (var part in plate.Parts)
-            {
-                var support = supports.Analyze(part, bed, plate.Quadrant, clearance);
-                if (support is not { IsComplete: true })
-                    continue;
-                scene.Supports.Add(new SupportItem(support.Contacts, support.CenterOfGravity, support.IsSupported,
-                    support.IsSupported ? null : support.BestTabPoint));
-            }
-        }
-
-        private static bool Contains(Box outer, Box inner) =>
-            inner.Left >= outer.Left && inner.Right <= outer.Right && inner.Bottom >= outer.Bottom && inner.Top <= outer.Top;
-
-        private static bool Intersects(Box a, Box b) =>
-            a.Left <= b.Right && a.Right >= b.Left && a.Bottom <= b.Top && a.Top >= b.Bottom;
-
         private static SKColor ToSkColor(System.Drawing.Color color) =>
             color.IsEmpty ? new SKColor(130, 204, 130) : new SKColor(color.R, color.G, color.B, color.A);
 
         protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
         {
             var at = e.GetPosition(this);
-            view.ZoomAt(new ScreenPoint(at.X, at.Y), System.Math.Pow(1.2, e.Delta.Y));
+            var factor = System.Math.Pow(1.2, e.Delta.Y);
+            // Keep the world point under the cursor fixed.
+            origin = new Point(at.X - (at.X - origin.X) * factor, at.Y - (at.Y - origin.Y) * factor);
+            scale *= factor;
             InvalidateVisual();
             ViewChanged?.Invoke(this, EventArgs.Empty);
             e.Handled = true;
@@ -344,7 +190,7 @@ namespace OpenNest.Avalonia.Controls
             var at = e.GetPosition(this);
             if (dragStart is { } start)
             {
-                view.Pan(at.X - start.X, at.Y - start.Y);
+                origin += at - start;
                 dragStart = at;
                 InvalidateVisual();
             }
@@ -388,11 +234,11 @@ namespace OpenNest.Avalonia.Controls
         protected override void OnSizeChanged(global::Avalonia.Controls.SizeChangedEventArgs e)
         {
             base.OnSizeChanged(e);
-            view.Resize(e.NewSize.Width, e.NewSize.Height);
+            if (fitPending)
-            InvalidateVisual();
+                InvalidateVisual();
         }
 
-        /// <summary>The topmost part whose material (or, for an etch-only part, closed mark) holds <paramref name="world"/>.</summary>
+        /// <summary>The topmost part whose material contains <paramref name="world"/>.</summary>
         private Part HitTest(Vector world)
         {
             if (plate == null)
@@ -404,57 +250,33 @@ namespace OpenNest.Avalonia.Controls
                 if (world.X < box.Left || world.X > box.Right || world.Y < box.Bottom || world.Y > box.Top)
                     continue;
                 var local = world - part.Location;
-                if (PathsFor(part).Selection.Contains((float)local.X, (float)local.Y))
+                if (PathsFor(part).Fill.Contains((float)local.X, (float)local.Y))
                     return part;
             }
             return null;
         }
 
-        private sealed record PartItem(PartPaths Paths, Vector Location, Box Bounds, SKColor Color, SKColor Outline,
+        private sealed record PartItem(ProgramPaths Paths, Vector Location, Box Bounds, SKColor Color,
-            string Label, Vector LabelPoint, bool Selected, bool Hovered, bool IsCutOff);
+            string Label, bool Selected, bool Hovered, bool IsCutOff, bool ShowLeads);
-
-        private sealed record SupportItem(IReadOnlyList<Vector> Contacts, Vector CenterOfGravity, bool Supported,
-            Vector? Tab);
-
-        /// <summary>Everything one frame draws, built on the UI thread and only read on the render thread.</summary>
-        private sealed class Scene
-        {
-            public Rect Bounds;
-            public SkiaSchemePalette Palette;
-            public SKMatrix Matrix;
-            public double Scale;
-            public bool DrawOrigin;
-            public Box Sheet;
-            public SKPath SheetOutline;
-            public SKPath Obstacles;
-            public SKPath Usable;
-            public Box EdgeSpacing;
-            public readonly List<PartItem> Parts = new();
-            public readonly List<(SKPath Path, Vector Location)> Offsets = new();
-            public Box SelectionBounds;
-            public IReadOnlyList<RapidEnumerator.Segment> Rapids;
-            public IReadOnlyList<Vector> PiercePoints;
-            public IReadOnlyList<ContourSample> Arrows;
-            public IReadOnlyList<Box> Clamps;
-            public IReadOnlyList<Box> RemovedClamps;
-            public IReadOnlyList<Line> CutOffStrokes;
-            public readonly List<IReadOnlyList<Vector>> CommonLines = new();
-            public readonly List<Box> CommonLineProblems = new();
-            public IReadOnlyList<Vector> GridPoints;
-            public IReadOnlyList<Box> Slats;
-            public readonly List<SupportItem> Supports = new();
-        }
 
         private sealed class PlateDrawOperation : ICustomDrawOperation
         {
-            private readonly Scene scene;
+            private readonly Box plateRect;
+            private readonly Spacing? edgeSpacing;
+            private readonly SKMatrix matrix;
+            private readonly List<PartItem> items;
 
-            public PlateDrawOperation(Scene scene)
+            public PlateDrawOperation(Rect bounds, Box plateRect, Spacing? edgeSpacing, SKMatrix matrix,
+                List<PartItem> items)
             {
-                this.scene = scene;
+                Bounds = bounds;
+                this.plateRect = plateRect;
+                this.edgeSpacing = edgeSpacing;
+                this.matrix = matrix;
+                this.items = items;
             }
 
-            public Rect Bounds => scene.Bounds;
+            public Rect Bounds { get; }
 
             public bool HitTest(Point p) => Bounds.Contains(p);
 
@@ -473,424 +295,90 @@ namespace OpenNest.Avalonia.Controls
                 var canvas = api.SkCanvas;
                 canvas.Save();
                 canvas.ClipRect(new SKRect(0, 0, (float)Bounds.Width, (float)Bounds.Height));
-                canvas.Clear(scene.Palette.Background);
+                canvas.Clear(BackgroundColor);
-                new PlatePainter(canvas, scene).Paint();
+
+                if (plateRect != null)
+                    Draw(canvas);
+
                 canvas.Restore();
             }
-        }
 
-        /// <summary>
+            private void Draw(SKCanvas canvas)
-        /// Paints a scene in the WinForms view's order and pen sizes: widths and dashes are screen
-        /// pixels, so parts drawn in world units scale them by the zoom.
-        /// </summary>
-        private sealed class PlatePainter
-        {
-            private static readonly SKColor LeadColor = new(255, 69, 0); // OrangeRed
-            private static readonly SKColor DisplayColor = new(70, 110, 140);
-            private static readonly SKColor OffsetColor = new(255, 100, 100, 120);
-            private static readonly SKColor CutDirectionColor = new(60, 60, 60);
-            private static readonly SKColor PierceFill = new(255, 0, 0);
-            private static readonly SKColor PierceOutline = new(139, 0, 0); // DarkRed
-            private static readonly SKColor ClampHatch = new(70, 80, 90, 150);
-            private static readonly SKColor ClampBack = new(230, 170, 40, 70);
-            private static readonly SKColor ClampOutline = new(150, 100, 0, 220);
-            private static readonly SKColor RemovedClampOutline = new(110, 110, 110, 200);
-            private static readonly SKColor ObstacleHatch = new(120, 60, 60, 170);
-            private static readonly SKColor ObstacleBack = new(200, 80, 80, 60);
-            private static readonly SKColor CutOffColor = new(255, 69, 0); // OrangeRed
-            private static readonly SKColor CommonLineColor = new(0, 150, 136);
-            private static readonly SKColor BrokenCommonLineColor = new(255, 0, 0);
-            private static readonly SKColor GridColor = new(120, 120, 120, 110);
-            private static readonly SKColor SlatColor = new(120, 120, 120, 90);
-            private static readonly SKColor ContactColor = new(30, 150, 60, 220);
-            private static readonly SKColor SupportedColor = new(20, 140, 50, 230);
-            private static readonly SKColor TippingColor = new(210, 30, 30, 240);
-            private static readonly SKColor TabColor = new(240, 140, 0, 240);
-
-            // The WinForms default font, bold and underlined, for part numbers.
-            private static readonly SKTypeface LabelTypeface =
-                SKTypeface.FromFamilyName(null, SKFontStyle.Bold) ?? SKTypeface.Default;
-
-            private readonly SKCanvas canvas;
-            private readonly Scene scene;
-            // Not readonly: SKCanvas.Concat takes it by reference.
-            private SKMatrix matrix;
-            private readonly float scale;
-
-            public PlatePainter(SKCanvas canvas, Scene scene)
             {
-                this.canvas = canvas;
+                // Hairline strokes (width 0) stay one pixel wide at any zoom.
-                this.scene = scene;
+                using var fill = new SKPaint { Style = SKPaintStyle.Fill, IsAntialias = true };
-                matrix = scene.Matrix;
+                using var stroke = new SKPaint { Style = SKPaintStyle.Stroke, StrokeWidth = 0, IsAntialias = true };
-                scale = (float)scene.Scale;
-            }
 
-            private SKPoint Screen(Vector world) => matrix.MapPoint((float)world.X, (float)world.Y);
-
-            private SKRect Screen(Box box)
-            {
-                var a = Screen(new Vector(box.Left, box.Top));
-                var b = Screen(new Vector(box.Right, box.Bottom));
-                return new SKRect(System.Math.Min(a.X, b.X), System.Math.Min(a.Y, b.Y),
-                    System.Math.Max(a.X, b.X), System.Math.Max(a.Y, b.Y));
-            }
-
-            private static SKPaint Stroke(SKColor color, float width = 1, float[] dash = null) => new()
-            {
-                Style = SKPaintStyle.Stroke,
-                Color = color,
-                StrokeWidth = width,
-                IsAntialias = true,
-                PathEffect = dash == null ? null : SKPathEffect.CreateDash(dash, 0),
-            };
-
-            private static SKPaint Fill(SKColor color) => new() { Style = SKPaintStyle.Fill, Color = color, IsAntialias = true };
-
-            // A pen of screen width in the world frame: width 1 stays a one-pixel hairline.
-            private SKPaint WorldStroke(SKColor color, float width = 1, float[] dash = null) =>
-                Stroke(color, width <= 1 && dash == null ? 0 : width / scale,
-                    dash?.Select(d => d / scale).ToArray());
-
-            public void Paint()
-            {
-                if (scene.DrawOrigin)
-                {
-                    using var origin = Stroke(scene.Palette.Origin);
-                    origin.IsAntialias = false;
-                    var o = Screen(Vector.Zero);
-                    canvas.DrawLine(o.X, 0, o.X, (float)scene.Bounds.Height, origin);
-                    canvas.DrawLine(0, o.Y, (float)scene.Bounds.Width, o.Y, origin);
-                }
-
-                if (scene.Sheet == null)
-                    return;
-
-                DrawSheet();
-                DrawParts();
-                DrawOffsets();
-                if (scene.SelectionBounds != null)
-                {
-                    using var pen = Stroke(scene.Palette.BoundingBox);
-                    canvas.DrawRect(Screen(scene.SelectionBounds), pen);
-                }
-                DrawRapids();
-                DrawPiercePoints();
-                DrawCutDirection();
-                DrawClamps();
-                DrawCutOffs();
-                DrawCommonLines();
-                DrawSupport();
-            }
-
-            private void DrawSheet()
-            {
-                var palette = scene.Palette;
                 canvas.Save();
-                canvas.Concat(ref matrix);
+                var world = matrix;
-                using var sheetFill = Fill(palette.PlateFill);
+                canvas.Concat(ref world);
-                if (scene.SheetOutline != null)
+
+                var plate = new SKRect((float)plateRect.Left, (float)plateRect.Bottom,
+                    (float)plateRect.Right, (float)plateRect.Top);
+                fill.Color = PlateFillColor;
+                canvas.DrawRect(plate, fill);
+                if (edgeSpacing is { } spacing)
                 {
-                    canvas.DrawPath(scene.SheetOutline, sheetFill);
+                    stroke.Color = EdgeSpacingColor;
-                    canvas.Restore();
+                    canvas.DrawRect(new SKRect(plate.Left + (float)spacing.Left,
-                    if (scene.Obstacles != null)
+                        plate.Top + (float)spacing.Bottom, plate.Right - (float)spacing.Right,
-                    {
+                        plate.Bottom - (float)spacing.Top), stroke);
-                        HatchPath(scene.Obstacles, ObstacleHatch, ObstacleBack);
-                        using var obstaclePen = WorldStroke(ObstacleHatch, 1.5f);
-                        DrawWorld(scene.Obstacles, obstaclePen);
-                    }
-                    if (scene.Usable != null)
-                    {
-                        using var usablePen = WorldStroke(palette.EdgeSpacing, 1, new float[] { 3, 3 });
-                        DrawWorld(scene.Usable, usablePen);
-                    }
-                    using var outlinePen = WorldStroke(palette.PlateOutline);
-                    DrawWorld(scene.SheetOutline, outlinePen);
-                    return;
                 }
+                stroke.Color = PlateOutlineColor;
+                canvas.DrawRect(plate, stroke);
 
-                var sheet = scene.Sheet;
+                var view = canvas.LocalClipBounds;
-                canvas.DrawRect(new SKRect((float)sheet.Left, (float)sheet.Bottom, (float)sheet.Right, (float)sheet.Top),
+                foreach (var item in items)
-                    sheetFill);
-                canvas.Restore();
-                if (scene.EdgeSpacing != null)
                 {
-                    using var edgePen = Stroke(palette.EdgeSpacing, 1, new float[] { 3, 3 });
+                    var b = item.Bounds;
-                    edgePen.IsAntialias = false;
+                    if (b.Right < view.Left || b.Left > view.Right || b.Top < view.Top || b.Bottom > view.Bottom)
-                    canvas.DrawRect(Screen(scene.EdgeSpacing), edgePen);
+                        continue;
-                }
-                using var outline = Stroke(palette.PlateOutline);
-                outline.IsAntialias = false;
-                canvas.DrawRect(Screen(sheet), outline);
-            }
 
-            private void DrawWorld(SKPath path, SKPaint paint)
-            {
-                canvas.Save();
-                canvas.Concat(ref matrix);
-                canvas.DrawPath(path, paint);
-                canvas.Restore();
-            }
-
-            // GDI+ WideUpwardDiagonal: three-pixel "/" stripes every eight pixels, in screen space.
-            private void HatchPath(SKPath worldPath, SKColor hatch, SKColor back)
-            {
-                using var screenPath = new SKPath(worldPath);
-                screenPath.Transform(matrix);
-                using var shader = HatchShader(hatch, back);
-                using var paint = new SKPaint { Style = SKPaintStyle.Fill, Shader = shader };
-                canvas.DrawPath(screenPath, paint);
-            }
-
-            private void HatchRect(SKRect rect, SKColor hatch, SKColor back)
-            {
-                using var shader = HatchShader(hatch, back);
-                using var paint = new SKPaint { Style = SKPaintStyle.Fill, Shader = shader };
-                canvas.DrawRect(rect, paint);
-            }
-
-            private static SKShader HatchShader(SKColor hatch, SKColor back)
-            {
-                using var bitmap = new SKBitmap(8, 8, SKColorType.Rgba8888, SKAlphaType.Unpremul);
-                for (var y = 0; y < 8; y++)
-                    for (var x = 0; x < 8; x++)
-                        bitmap.SetPixel(x, y, (x + y) % 8 < 3 ? hatch : back);
-                return SKShader.CreateBitmap(bitmap, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat);
-            }
-
-            private void DrawParts()
-            {
-                var palette = scene.Palette;
-                using var fill = Fill(SKColors.Black);
-                using var cut = WorldStroke(SKColors.Black);
-                using var etch = WorldStroke(palette.Etch, 1.5f);
-                using var lead = WorldStroke(LeadColor, 1.5f);
-                using var display = WorldStroke(DisplayColor, 1, new float[] { 6, 3 });
-                using var text = new SKPaint
-                {
-                    Color = SKColors.Black,
-                    IsAntialias = true,
-                    TextSize = 11,
-                    Typeface = LabelTypeface,
-                    TextAlign = SKTextAlign.Center,
-                };
-                using var underline = Stroke(SKColors.Black);
-                var metrics = text.FontMetrics;
-                var textHeight = metrics.Descent - metrics.Ascent;
-
-                foreach (var item in scene.Parts)
-                {
                     canvas.Save();
-                    canvas.Concat(ref matrix);
                     canvas.Translate((float)item.Location.X, (float)item.Location.Y);
 
-                    fill.Color = item.Selected ? palette.SelectedFill
+                    fill.Color = item.Selected ? SelectedColor
                         : item.Hovered ? Lighten(item.Color) : item.Color;
-                    canvas.DrawPath(item.Paths.Material, fill);
+                    canvas.DrawPath(item.Paths.Fill, fill);
-                    if (item.Paths.Display != null)
-                        canvas.DrawPath(item.Paths.Display, display);
-                    canvas.DrawPath(item.Paths.Etch, etch);
-                    // Keep real cuts visible even where an etch overlaps them.
-                    cut.Color = item.Selected ? palette.SelectedOutline : item.Outline;
-                    canvas.DrawPath(item.Paths.Cut, cut);
-                    // As on the desktop, only manually placed lead-ins are shown.
-                    canvas.DrawPath(item.Paths.Lead, lead);
-                    canvas.Restore();
 
-                    // A number shows only once the part is big enough on screen to hold it.
+                    stroke.Color = EtchColor;
+                    canvas.DrawPath(item.Paths.Etch, stroke);
+                    stroke.Color = item.Selected ? new SKColor(30, 90, 200) : Darken(item.Color);
+                    canvas.DrawPath(item.Paths.Cut, stroke);
+                    // As on the desktop, only manually placed lead-ins are shown.
+                    if (item.ShowLeads)
+                    {
+                        stroke.Color = LeadColor;
+                        canvas.DrawPath(item.Paths.Lead, stroke);
+                    }
+
+                    canvas.Restore();
+                }
+
+                canvas.Restore();
+                DrawLabels(canvas);
+            }
+
+            // Ids are drawn in screen space and only where the part is big enough on screen to hold one.
+            private void DrawLabels(SKCanvas canvas)
+            {
+                using var text = new SKPaint { Color = SKColors.Black, IsAntialias = true, TextSize = 12 };
+                foreach (var item in items)
+                {
                     if (item.IsCutOff)
                         continue;
-                    var bounds = Screen(item.Bounds);
+                    var center = matrix.MapPoint((float)item.Bounds.Center.X, (float)item.Bounds.Center.Y);
-                    var width = text.MeasureText(item.Label);
+                    var width = item.Bounds.Length * matrix.ScaleX;
-                    if (bounds.Width < width || bounds.Height < textHeight)
+                    var height = item.Bounds.Width * -matrix.ScaleY;
+                    var measured = text.MeasureText(item.Label);
+                    if (measured + 4 > width || text.TextSize + 4 > height)
                         continue;
-                    var at = Screen(item.LabelPoint);
+                    canvas.DrawText(item.Label, center.X - measured / 2, center.Y + text.TextSize / 3, text);
-                    var baseline = at.Y - (metrics.Ascent + metrics.Descent) / 2;
-                    canvas.DrawText(item.Label, at.X, baseline, text);
-                    var lineY = baseline + System.Math.Max(1, metrics.UnderlinePosition ?? 1.5f);
-                    canvas.DrawLine(at.X - width / 2, lineY, at.X + width / 2, lineY, underline);
                 }
             }
 
-            private void DrawOffsets()
+            private static SKColor Darken(SKColor c) =>
-            {
+                new((byte)(c.Red * 0.55), (byte)(c.Green * 0.55), (byte)(c.Blue * 0.55), 255);
-                if (scene.Offsets.Count == 0)
-                    return;
-                using var pen = WorldStroke(OffsetColor);
-                foreach (var (path, location) in scene.Offsets)
-                {
-                    canvas.Save();
-                    canvas.Concat(ref matrix);
-                    canvas.Translate((float)location.X, (float)location.Y);
-                    canvas.DrawPath(path, pen);
-                    canvas.Restore();
-                }
-            }
-
-            private void DrawRapids()
-            {
-                if (scene.Rapids == null)
-                    return;
-                using var pen = Stroke(scene.Palette.Rapid, 1, new float[] { 10, 10 });
-                foreach (var segment in scene.Rapids)
-                    canvas.DrawLine(Screen(segment.From), Screen(segment.To), pen);
-            }
-
-            private void DrawPiercePoints()
-            {
-                if (scene.PiercePoints == null)
-                    return;
-                using var fill = Fill(PierceFill);
-                using var pen = Stroke(PierceOutline);
-                foreach (var point in scene.PiercePoints)
-                {
-                    var p = Screen(point);
-                    canvas.DrawCircle(p, 2, fill);
-                    canvas.DrawCircle(p, 2, pen);
-                }
-            }
-
-            private void DrawCutDirection()
-            {
-                if (scene.Arrows == null)
-                    return;
-                const float size = 6;
-                using var pen = Stroke(CutDirectionColor, 1.5f);
-                foreach (var sample in scene.Arrows)
-                {
-                    var tip = Screen(sample.Position);
-                    // Screen space flips Y, so the screen angle mirrors the world tangent.
-                    var angle = System.Math.Atan2(-sample.Direction.Y, sample.Direction.X);
-                    foreach (var side in new[] { 0.5, -0.5 })
-                    {
-                        var a = angle + System.Math.PI + side;
-                        canvas.DrawLine(tip.X + size * (float)System.Math.Cos(a), tip.Y + size * (float)System.Math.Sin(a),
-                            tip.X, tip.Y, pen);
-                    }
-                }
-            }
-
-            // Machine clamps are fixtures, not material: a translucent hatched amber keep-out.
-            private void DrawClamps()
-            {
-                using var outline = Stroke(ClampOutline, 1.5f);
-                foreach (var clamp in scene.Clamps)
-                {
-                    var rect = Screen(clamp);
-                    HatchRect(rect, ClampHatch, ClampBack);
-                    canvas.DrawRect(rect, outline);
-                }
-
-                using var removed = Stroke(RemovedClampOutline, 1.5f, new float[] { 4.5f, 1.5f });
-                using var text = new SKPaint { Color = RemovedClampOutline, IsAntialias = true, TextSize = 9 };
-                foreach (var clamp in scene.RemovedClamps)
-                {
-                    var rect = Screen(clamp);
-                    canvas.DrawRect(rect, removed);
-                    canvas.DrawText("remove", rect.Left, rect.Top - text.FontMetrics.Descent, text);
-                }
-            }
-
-            // Scrap cut-off lines stand out from the dark part outlines: a saturated orange-red dash.
-            private void DrawCutOffs()
-            {
-                using var pen = Stroke(CutOffColor, 2, new float[] { 6, 2 });
-                foreach (var stroke in scene.CutOffStrokes)
-                    canvas.DrawLine(Screen(stroke.StartPoint), Screen(stroke.EndPoint), pen);
-
-                // Each segment's number over the line, on a disc of the line's colour.
-                using var disc = Fill(CutOffColor);
-                using var text = new SKPaint
-                {
-                    Color = SKColors.White,
-                    IsAntialias = true,
-                    TextSize = 11,
-                    Typeface = LabelTypeface,
-                    TextAlign = SKTextAlign.Center,
-                };
-                var metrics = text.FontMetrics;
-                var textHeight = metrics.Descent - metrics.Ascent;
-                foreach (var item in scene.Parts)
-                {
-                    if (!item.IsCutOff)
-                        continue;
-                    var bounds = Screen(item.Bounds);
-                    var diameter = System.Math.Max(text.MeasureText(item.Label), textHeight) + 2;
-                    if (System.Math.Max(bounds.Width, bounds.Height) < diameter)
-                        continue;
-                    var at = Screen(item.LabelPoint);
-                    canvas.DrawCircle(at, diameter / 2, disc);
-                    canvas.DrawText(item.Label, at.X, at.Y - (metrics.Ascent + metrics.Descent) / 2, text);
-                }
-            }
-
-            private void DrawCommonLines()
-            {
-                using var pen = Stroke(CommonLineColor, 2, new float[] { 6, 2 });
-                foreach (var points in scene.CommonLines)
-                    for (var i = 1; i < points.Count; i++)
-                        canvas.DrawLine(Screen(points[i - 1]), Screen(points[i]), pen);
-                using var broken = Stroke(BrokenCommonLineColor, 2);
-                foreach (var box in scene.CommonLineProblems)
-                    canvas.DrawRect(Screen(box), broken);
-            }
-
-            private void DrawSupport()
-            {
-                if (scene.GridPoints != null)
-                {
-                    // Whole-pixel squares, not anti-aliased dots, so every point is the same size.
-                    using var grid = new SKPaint { Style = SKPaintStyle.Fill, Color = GridColor, IsAntialias = false };
-                    foreach (var point in scene.GridPoints)
-                    {
-                        var p = Screen(point);
-                        var x = (float)System.Math.Round(p.X) - 1;
-                        var y = (float)System.Math.Round(p.Y) - 1;
-                        canvas.DrawRect(x, y, 3, 3, grid);
-                    }
-                }
-                if (scene.Slats != null)
-                {
-                    using var slat = new SKPaint { Style = SKPaintStyle.Fill, Color = SlatColor, IsAntialias = false };
-                    foreach (var box in scene.Slats)
-                    {
-                        var rect = Screen(box);
-                        // At least a pixel wide however far out the view is.
-                        if (rect.Width < 1)
-                            rect = new SKRect(rect.MidX - 0.5f, rect.Top, rect.MidX + 0.5f, rect.Bottom);
-                        if (rect.Height < 1)
-                            rect = new SKRect(rect.Left, rect.MidY - 0.5f, rect.Right, rect.MidY + 0.5f);
-                        canvas.DrawRect(rect, slat);
-                    }
-                }
-
-                using var contact = Fill(ContactColor);
-                using var supported = Stroke(SupportedColor, 2);
-                using var tipping = Stroke(TippingColor, 2);
-                using var tab = Fill(TabColor);
-                foreach (var item in scene.Supports)
-                {
-                    foreach (var point in item.Contacts)
-                        canvas.DrawCircle(Screen(point), 2.5f, contact);
-                    const float size = 6;
-                    var c = Screen(item.CenterOfGravity);
-                    var pen = item.Supported ? supported : tipping;
-                    canvas.DrawCircle(c, size, pen);
-                    canvas.DrawLine(c.X - size, c.Y, c.X + size, c.Y, pen);
-                    canvas.DrawLine(c.X, c.Y - size, c.X, c.Y + size, pen);
-                    if (item.Tab is { } point2)
-                    {
-                        const float d = 5;
-                        var t = Screen(point2);
-                        using var diamond = new SKPath();
-                        diamond.MoveTo(t.X, t.Y - d);
-                        diamond.LineTo(t.X + d, t.Y);
-                        diamond.LineTo(t.X, t.Y + d);
-                        diamond.LineTo(t.X - d, t.Y);
-                        diamond.Close();
-                        canvas.DrawPath(diamond, tab);
-                    }
-                }
-            }
 
             private static SKColor Lighten(SKColor c) =>
                 new((byte)(c.Red + (255 - c.Red) / 2), (byte)(c.Green + (255 - c.Green) / 2),

OpenNest.Avalonia/DesktopSettings.cs

@@ -1,80 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using OpenNest.Data;
-using OpenNest.Desktop;
-
-namespace OpenNest.Avalonia
-{
-    /// <summary>
-    /// The machines, nest defaults and post processors this app works with, from the shared
-    /// desktop library: in Database mode (storage.json, shared with the WinForms app) the nest
-    /// server's copy once it holds one, otherwise this PC's files, with the user settings both
-    /// apps keep in user-settings.json.
-    /// </summary>
-    internal static class DesktopSettings
-    {
-        public static SharedSettingsSource Shared { get; } = SharedSettingsSource.FromStorageFile();
-
-        public static MachineSettingsSource Machines { get; } =
-            new(Shared, new MachineUserSettingsFile(UserSettingsFile.DefaultPath));
-
-        /// <summary>The storage mode and nest server, read once from storage.json as <see cref="Shared"/> does.</summary>
-        private static readonly NestStorageSettings Storage = NestStorageSettings.Load(NestStorageSettings.DefaultPath);
-
-        private static RemoteNestRepository repository;
-
-        /// <summary>
-        /// File > New nests, numbered by the nest server in Database mode and otherwise by the
-        /// counter both apps keep in user-settings.json.
-        /// </summary>
-        public static NewNestSource NewNests { get; } = new(
-            Machines,
-            new NewNestUserSettingsFile(UserSettingsFile.DefaultPath),
-            () => Storage.IsDatabaseMode ? repository ??= new RemoteNestRepository(Storage.ServerUrl) : null);
-
-        /// <summary>The post processors loaded from Posts/ beside the app, by load order.</summary>
-        public static IReadOnlyList<IPostProcessor> PostProcessors { get; private set; } = [];
-
-        /// <summary>The readable machine configurations, once <see cref="LoadMachinesAsync"/> has run.</summary>
-        public static IReadOnlyList<MachineConfig> MachineConfigs { get; private set; } = [];
-
-        /// <summary>
-        /// Loads the post processors in <paramref name="directory"/> (each DLL on its own, so one
-        /// that fails does not stop the others) and registers their materials. Returns the
-        /// failures to show, or null when every post loaded.
-        /// </summary>
-        public static string LoadPosts(string directory)
-        {
-            var result = PostProcessorLoader.Load(directory);
-            PostProcessors = result.PostProcessors;
-            return result.Failures.Count == 0
-                ? null
-                : "These post processors could not be loaded: " + string.Join("; ", result.Failures);
-        }
-
-        /// <summary>
-        /// Reads the machines off the UI thread (the nest server can take seconds to answer), then
-        /// copies the legacy clamps onto the default or only machine, as the WinForms app does at
-        /// startup (with several machines and no default it waits for the WinForms app to ask).
-        /// Returns what to tell the user: the machines' source when the server could not be
-        /// reached, or why the clamps were not copied; null when there is nothing to say.
-        /// </summary>
-        public static Task<string> LoadMachinesAsync() => Task.Run(() =>
-        {
-            MachineConfigs = Machines.LoadMachines();
-            var clamps = Machines.MigrateLegacyClamps(askMachine: null);
-            var offline = Shared.TakeOfflineWarning();
-            var notices = new[] { offline, clamps }
-                .Where(text => !string.IsNullOrEmpty(text))
-                .Select(OneLine)
-                .ToList();
-            return notices.Count == 0 ? null : string.Join("   ", notices);
-        });
-
-        private static string OneLine(string text) =>
-            string.Join(" ", text.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries));
-    }
-}

OpenNest.Avalonia/MainWindow.View.cs

@@ -1,92 +0,0 @@
-using System;
-using Avalonia.Controls;
-using Avalonia.Interactivity;
-using OpenNest.Data;
-using OpenNest.Desktop.Rendering;
-
-namespace OpenNest.Avalonia
-{
-    /// <summary>
-    /// View &gt; Draw Rapids, Pierce Points, Bounds, Offset, Cut Direction and Support: toggles of the
-    /// active nest's plate view, as each WinForms nest window keeps its own. Rapids and bounds are
-    /// read from the shared user settings when a nest opens and written back when it closes.
-    /// </summary>
-    public partial class MainWindow
-    {
-        private void RestoreViewToggles(NestView view) =>
-            view.PlateView.Options = snapshotMode
-                ? new PlateViewOptions()
-                : PlateViewOptions.Read(UserSettingsFile.Read(UserSettingsFile.DefaultPath));
-
-        // A snapshot must not depend on the user's settings.
-        private void UseDefaultViewToggles()
-        {
-            foreach (var view in views.Values)
-            {
-                view.PlateView.Options = new PlateViewOptions();
-                view.PlateView.InvalidateVisual();
-            }
-            UpdateViewToggles();
-        }
-
-        private void SaveViewToggles(NestView view)
-        {
-            if (snapshotMode)
-                return;
-            UserSettingsFile.Update(UserSettingsFile.DefaultPath, view.PlateView.Options.WriteTo);
-        }
-
-        // As the WinForms nest windows closing in turn: the last one's toggles are kept.
-        private void SaveAllViewToggles()
-        {
-            foreach (var tab in tabs.Tabs)
-            {
-                if (views.TryGetValue(tab, out var view))
-                    SaveViewToggles(view);
-            }
-        }
-
-        private void UpdateViewToggles()
-        {
-            var options = ActiveView?.PlateView.Options;
-            foreach (var (item, value) in new (MenuItem, Func<PlateViewOptions, bool>)[]
-            {
-                (DrawRapidsMenuItem, o => o.DrawRapid),
-                (DrawPiercePointsMenuItem, o => o.DrawPiercePoints),
-                (DrawBoundsMenuItem, o => o.DrawBounds),
-                (DrawOffsetMenuItem, o => o.DrawOffset),
-                (DrawCutDirectionMenuItem, o => o.DrawCutDirection),
-                (DrawSupportMenuItem, o => o.DrawSupport),
-            })
-            {
-                item.IsEnabled = options != null;
-                item.IsChecked = options != null && value(options);
-            }
-        }
-
-        private void Toggle(Action<PlateViewOptions> toggle)
-        {
-            if (ActiveView is { } view)
-            {
-                toggle(view.PlateView.Options);
-                view.PlateView.InvalidateVisual();
-            }
-            UpdateViewToggles();
-        }
-
-        private void OnToggleDrawRapids(object sender, RoutedEventArgs e) => Toggle(o => o.DrawRapid = !o.DrawRapid);
-
-        private void OnToggleDrawPiercePoints(object sender, RoutedEventArgs e) =>
-            Toggle(o => o.DrawPiercePoints = !o.DrawPiercePoints);
-
-        private void OnToggleDrawBounds(object sender, RoutedEventArgs e) => Toggle(o => o.DrawBounds = !o.DrawBounds);
-
-        private void OnToggleDrawOffset(object sender, RoutedEventArgs e) => Toggle(o => o.DrawOffset = !o.DrawOffset);
-
-        private void OnToggleDrawCutDirection(object sender, RoutedEventArgs e) =>
-            Toggle(o => o.DrawCutDirection = !o.DrawCutDirection);
-
-        private void OnToggleDrawSupport(object sender, RoutedEventArgs e) =>
-            Toggle(o => o.DrawSupport = !o.DrawSupport);
-    }
-}

OpenNest.Avalonia/MainWindow.axaml

@@ -1,80 +1,56 @@
 <Window xmlns="https://github.com/avaloniaui"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:c="using:OpenNest.Avalonia.Controls"
+        xmlns:local="using:OpenNest.Avalonia"
         x:Class="OpenNest.Avalonia.MainWindow"
         Title="OpenNest (Avalonia prototype)"
         Width="1400" Height="860">
   <DockPanel>
     <Menu DockPanel.Dock="Top">
       <MenuItem Header="_File">
-        <MenuItem x:Name="NewMenuItem" Header="_New" InputGesture="Ctrl+N" Click="OnNew" />
+        <MenuItem Header="_Open..." InputGesture="Ctrl+O" Click="OnOpen" />
-        <MenuItem x:Name="OpenMenuItem" Header="_Open..." InputGesture="Ctrl+O" Click="OnOpen" />
         <Separator />
-        <MenuItem x:Name="SaveMenuItem" Header="_Save" InputGesture="Ctrl+S" Click="OnSave" />
+        <MenuItem Header="E_xit" Click="OnExit" />
-        <MenuItem x:Name="SaveAsMenuItem" Header="Save _As..." Click="OnSaveAs" />
-        <MenuItem x:Name="ExportNestMenuItem" Header="Save _Copy as .nest File..." Click="OnExportNest" />
-        <Separator />
-        <MenuItem x:Name="CloseMenuItem" Header="_Close" Click="OnCloseNest" />
-        <MenuItem x:Name="CloseAllMenuItem" Header="Close A_ll" Click="OnCloseAll" />
-        <Separator />
-        <MenuItem Header="E_xit" InputGesture="Ctrl+Q" Click="OnExit" />
-      </MenuItem>
-      <MenuItem Header="_Nest">
-        <MenuItem x:Name="AutoNestMenuItem" Header="_Auto Nest" Click="OnAutoNest" />
       </MenuItem>
       <MenuItem Header="_View">
-        <MenuItem x:Name="DrawRapidsMenuItem" Header="Draw _Rapids" ToggleType="CheckBox"
-                  Click="OnToggleDrawRapids" />
-        <MenuItem x:Name="DrawPiercePointsMenuItem" Header="Draw _Pierce Points" ToggleType="CheckBox"
-                  Click="OnToggleDrawPiercePoints" />
-        <MenuItem x:Name="DrawBoundsMenuItem" Header="Draw _Bounds" ToggleType="CheckBox"
-                  Click="OnToggleDrawBounds" />
-        <MenuItem x:Name="DrawOffsetMenuItem" Header="Draw _Offset" ToggleType="CheckBox"
-                  Click="OnToggleDrawOffset" />
-        <MenuItem x:Name="DrawCutDirectionMenuItem" Header="Draw _Cut Direction" ToggleType="CheckBox"
-                  Click="OnToggleDrawCutDirection" />
-        <MenuItem x:Name="DrawSupportMenuItem" Header="Draw _Support" ToggleType="CheckBox"
-                  Click="OnToggleDrawSupport" />
-        <Separator />
         <MenuItem Header="Zoom to _Fit" InputGesture="F" Click="OnFit" />
         <MenuItem Header="_Previous Plate" InputGesture="PageUp" Click="OnPreviousPlate" />
         <MenuItem Header="_Next Plate" InputGesture="PageDown" Click="OnNextPlate" />
-        <Separator />
-        <MenuItem Header="Next N_est" InputGesture="Ctrl+Tab" Click="OnNextNest" />
-        <MenuItem Header="Previous Ne_st" InputGesture="Ctrl+Shift+Tab" Click="OnPreviousNest" />
       </MenuItem>
     </Menu>
 
     <Border DockPanel.Dock="Top" Padding="4" BorderThickness="0,0,0,1" BorderBrush="#D0D0D0">
       <StackPanel Orientation="Horizontal" Spacing="4">
-        <Button x:Name="NewButton" Content="New" Click="OnNew" />
+        <Button Content="Open" Click="OnOpen" />
-        <Button x:Name="OpenButton" Content="Open" Click="OnOpen" />
-        <Button x:Name="SaveButton" Content="Save" Click="OnSave" />
-        <Button x:Name="SaveAsButton" Content="Save As" Click="OnSaveAs" />
         <Button Content="Fit" Click="OnFit" />
         <Button Content="Previous" Click="OnPreviousPlate" />
         <Button Content="Next" Click="OnNextPlate" />
-        <Button x:Name="AutoNestButton" Content="Auto Nest" Click="OnAutoNest" />
       </StackPanel>
     </Border>
 
     <Border DockPanel.Dock="Bottom" Padding="6,3" Background="#F0F0F0">
-      <TextBlock x:Name="Status" Text="Create a new nest or open a .nest file to begin." />
+      <TextBlock x:Name="Status" Text="Open a .nest file to begin." />
     </Border>
 
-    <!-- One tab per open nest, along the bottom of the window. -->
+    <Grid ColumnDefinitions="260,4,*,4,320">
-    <Border DockPanel.Dock="Bottom" Background="#E4E7EA">
+      <DockPanel Grid.Column="0">
-      <ScrollViewer HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Disabled">
+        <TextBlock DockPanel.Dock="Top" Margin="6,6,6,2" FontWeight="SemiBold" Text="Plates" />
-        <StackPanel x:Name="TabStrip" Orientation="Horizontal" Margin="6,0,6,6" />
+        <ListBox x:Name="PlateList" SelectionChanged="OnPlateSelected" />
-      </ScrollViewer>
+      </DockPanel>
-    </Border>
+      <GridSplitter Grid.Column="1" ResizeDirection="Columns" />
-
+      <c:PlateCanvas Grid.Column="2" x:Name="Canvas" />
-    <Panel>
+      <GridSplitter Grid.Column="3" ResizeDirection="Columns" />
-      <!-- The empty workspace, as in the WinForms app: dark, with the OpenNest logo centered. -->
+      <DockPanel Grid.Column="4">
-      <Panel x:Name="EmptyHint" Background="#2B2B2B">
+        <TextBlock DockPanel.Dock="Top" Margin="6,6,6,2" FontWeight="SemiBold" Text="Drawings on plate" />
-        <Image Source="avares://OpenNest.Avalonia/Assets/watermark.png" Stretch="None"
+        <DataGrid x:Name="DrawingGrid" x:DataType="local:DrawingRow" IsReadOnly="True"
-               HorizontalAlignment="Center" VerticalAlignment="Center" />
+                  AutoGenerateColumns="False" GridLinesVisibility="Horizontal" CanUserSortColumns="True">
-      </Panel>
+          <DataGrid.Columns>
-      <ContentControl x:Name="NestHost" />
+            <DataGridTextColumn Header="Drawing" Binding="{Binding Name}" Width="*" />
-    </Panel>
+            <DataGridTextColumn Header="Qty" Binding="{Binding Count}" />
+            <DataGridTextColumn Header="Size" Binding="{Binding Size}" />
+          </DataGrid.Columns>
+        </DataGrid>
+      </DockPanel>
+    </Grid>
   </DockPanel>
 </Window>

OpenNest.Avalonia/MainWindow.axaml.cs

@@ -1,765 +1,125 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Interactivity;
-using Avalonia.Layout;
-using Avalonia.Media;
 using Avalonia.Platform.Storage;
-using OpenNest.Desktop;
-using OpenNest.Engine;
-using OpenNest.Engine.Jobs;
-using OpenNest.Forms;
 using OpenNest.IO;
 
 namespace OpenNest.Avalonia
 {
+    public sealed record DrawingRow(string Name, int Count, string Size);
+
     public partial class MainWindow : Window
     {
-        private static readonly IBrush Accent = Brush.Parse("#3368A0");
+        private Nest nest;
-        private static readonly IBrush Muted = Brush.Parse("#6B7280");
+        private string fileName;
-        private static readonly IBrush InactiveTab = Brush.Parse("#DDE1E5");
-
-        private readonly NestTabs tabs = new();
-        private readonly Dictionary<NestTab, NestView> views = new();
-        private string notice;
-        private CancellationTokenSource nesting;
-        private NestTab nestingTab;
-        private Task autoNest = Task.CompletedTask;
-        private bool closeConfirmed;
-        // A File > New waiting on the machines or the nest number.
-        private bool creatingNest;
-        private bool snapshotMode;
-        // A save or export waiting on its file picker or write; another one waits for it.
-        private bool writingFile;
-        // True while Exit asks about unsaved nests, so a second close request is ignored.
-        private bool askingToExit;
-        // Load warnings shown one dialog at a time, once the window is open.
-        private readonly Queue<(string Name, IReadOnlyList<string> Warnings)> pendingWarnings =
-            new();
-        private bool showingWarnings;
 
         public MainWindow()
         {
             InitializeComponent();
-            // As the desktop app: plug-in engines first, then the saved engine selection.
+            Canvas.ViewChanged += (_, _) => UpdateStatus();
-            NestingEngineRegistry.LoadPlugins(Path.Combine(AppContext.BaseDirectory, "Engines"));
-            var engineWarning = EngineSelection.LoadSavedSelection();
-            if (!string.IsNullOrEmpty(engineWarning))
-                notice = engineWarning;
-            // Post processors from Posts/ (their materials registered), then the machines,
-            // reported in the status line as the WinForms app reports them in dialogs.
-            if (DesktopSettings.LoadPosts(Path.Combine(AppContext.BaseDirectory, "Posts")) is { } postWarning)
-                notice = notice == null ? postWarning : $"{notice}   {postWarning}";
-            MachinesLoaded = LoadMachinesAsync();
-            // The colour scheme chosen in the WinForms app's options, from the shared user settings.
-            ColorSchemeRegistry.ApplySaved(Data.UserSettingsFile.Read(Data.UserSettingsFile.DefaultPath));
-            tabs.Changed += (_, _) => ShowActiveTab();
-            KeyBindings.Add(new KeyBinding
-            {
-                Gesture = new KeyGesture(Key.N, KeyModifiers.Control),
-                Command = new Command(() => OnNew(null, null)),
-            });
             KeyBindings.Add(new KeyBinding
             {
                 Gesture = new KeyGesture(Key.O, KeyModifiers.Control),
                 Command = new Command(() => OnOpen(null, null)),
             });
-            KeyBindings.Add(new KeyBinding
-            {
-                Gesture = new KeyGesture(Key.S, KeyModifiers.Control),
-                Command = new Command(() => OnSave(null, null)),
-            });
-            KeyBindings.Add(new KeyBinding
-            {
-                Gesture = new KeyGesture(Key.Q, KeyModifiers.Control),
-                Command = new Command(() => OnExit(null, null)),
-            });
             KeyBindings.Add(new KeyBinding { Gesture = new KeyGesture(Key.PageUp), Command = new Command(() => StepPlate(-1)) });
             KeyBindings.Add(new KeyBinding { Gesture = new KeyGesture(Key.PageDown), Command = new Command(() => StepPlate(1)) });
-            // Ctrl+Tab before focus navigation takes the Tab key.
-            AddHandler(KeyDownEvent, OnPreviewKeyDown, RoutingStrategies.Tunnel);
-            // .nest files dropped anywhere on the window, the nest view included, open in tabs.
-            DragDrop.SetAllowDrop(this, true);
-            AddHandler(DragDrop.DragEnterEvent, OnDragOver);
-            AddHandler(DragDrop.DragOverEvent, OnDragOver);
-            AddHandler(DragDrop.DropEvent, OnDrop);
-            Closing += OnWindowClosing;
-            Opened += (_, _) =>
-            {
-                if (!snapshotMode)
-                    _ = ShowLoadWarningsAsync();
-            };
-            ShowActiveTab();
         }
 
-        // Null while a new tab's view is still being created.
-        private NestView ActiveView =>
-            tabs.Active != null && views.TryGetValue(tabs.Active, out var view) ? view : null;
-
-        /// <summary>Opens the nest in a new tab, or switches to its tab if open.</summary>
         public void OpenNest(string path)
         {
             try
             {
-                IReadOnlyList<string> warnings = Array.Empty<string>();
+                nest = new NestReader(path).Read();
-                var tab = tabs.Open(path, file =>
-                {
-                    var reader = new NestReader(file);
-                    var document = new Document { Nest = reader.Read() };
-                    warnings = reader.Warnings;
-                    // The view follows the application's scheme, not the one the file was saved under.
-                    ColorSchemeRegistry.RecolorDrawings(document.Nest);
-                    return document;
-                });
-                if (!views.ContainsKey(tab))
-                    AddView(tab);
-                if (warnings.Count > 0)
-                {
-                    var count = warnings.Count == 1
-                        ? "1 load warning"
-                        : $"{warnings.Count} load warnings";
-                    ShowNotice($"{tab.Name}: {count}");
-                    pendingWarnings.Enqueue((tab.Name, warnings));
-                    if (IsVisible && !snapshotMode)
-                        _ = ShowLoadWarningsAsync();
-                }
             }
             catch (Exception ex)
             {
-                ShowNotice($"Could not open {Path.GetFileName(path)}: {ex.Message}");
+                Status.Text = $"Could not open {Path.GetFileName(path)}: {ex.Message}";
-            }
-        }
-
-        /// <summary>
-        /// Opens a new nest from the nest defaults, the default machine with its clamps and
-        /// support grid, and the year's next name, in a new tab, as File > New does in WinForms.
-        /// </summary>
-        public async Task NewNestAsync()
-        {
-            // One at a time, so two nests never take the same number.
-            if (creatingNest)
-                return;
-            creatingNest = true;
-            NewNest created;
-            try
-            {
-                // The machines finish loading first; reading them and the nest number may wait
-                // on the nest server, so neither runs on the UI thread.
-                await MachinesLoaded;
-                created = await Task.Run(() => DesktopSettings.NewNests.CreateAsync());
-            }
-            catch (Exception ex)
-            {
-                ShowNotice($"Could not create a new nest: {ex.Message}");
                 return;
             }
-            finally
+
-            {
+            fileName = Path.GetFileName(path);
-                creatingNest = false;
+            Title = $"{fileName} - OpenNest (Avalonia prototype)";
-            }
+            Canvas.ClearCache();
-            AddView(tabs.Add(new Document { Nest = created.Nest }));
+            PlateList.ItemsSource = nest.Plates
-            if (created.Warning != null)
+                .Select((plate, i) => $"Plate {i + 1}   {plate.Size.Length:0.###} x {plate.Size.Width:0.###}   ({plate.Parts.Count} parts)")
-                await ConfirmDialog.ShowAsync(this, "Nest Defaults", created.Warning);
+                .ToList();
+            PlateList.SelectedIndex = nest.Plates.Count > 0 ? 0 : -1;
         }
 
-        private void AddView(NestTab tab)
-        {
-            var view = new NestView(tab);
-            RestoreViewToggles(view);
-            view.ViewChanged += (_, _) => { if (view == ActiveView) UpdateStatus(); };
-            views[tab] = view;
-            notice = null;
-            ShowActiveTab();
-        }
-
-        /// <summary>
-        /// Restores the window's size, position and maximized state from the user settings the
-        /// WinForms app shares, and saves them on close. Not used for --snapshot, whose image
-        /// must not depend on the user's settings.
-        /// </summary>
-        public void RememberPlacement() =>
-            WindowPlacementBinding.Remember(
-                this, WindowPlacement.MainWindow, Data.UserSettingsFile.DefaultPath);
-
-        /// <summary>Runs Auto Nest once the window opens, for --auto-nest.</summary>
-        public void AutoNestOnOpen() => Opened += (_, _) => autoNest = RunAutoNestAsync();
-
         public void SaveSnapshotAndClose(string path, int plateNumber)
         {
-            // No dialogs: the image is taken and the window closes unattended.
-            snapshotMode = true;
-            UseDefaultViewToggles();
             Opened += async (_, _) =>
             {
-                ActiveView?.ShowPlate(plateNumber - 1);
+                if (nest?.Plates.Count > 0)
-                await autoNest;
+                    PlateList.SelectedIndex = System.Math.Clamp(plateNumber - 1, 0, nest.Plates.Count - 1);
-                await Task.Delay(500);
+                await System.Threading.Tasks.Task.Delay(500);
-                var size = new PixelSize((int)Bounds.Width, (int)Bounds.Height);
+                var size = new global::Avalonia.PixelSize((int)Bounds.Width, (int)Bounds.Height);
                 using var bitmap = new global::Avalonia.Media.Imaging.RenderTargetBitmap(size);
                 bitmap.Render(this);
                 bitmap.Save(path);
-                // The status line beside the image, so headless checks can read it.
-                File.WriteAllText(path + ".txt", Status.Text);
-                closeConfirmed = true;
                 Close();
             };
         }
 
-        private void ShowActiveTab()
-        {
-            var view = ActiveView;
-            NestHost.Content = view;
-            EmptyHint.IsVisible = view == null;
-            CloseMenuItem.IsEnabled = view != null;
-            SaveMenuItem.IsEnabled = view != null;
-            SaveAsMenuItem.IsEnabled = view != null;
-            ExportNestMenuItem.IsEnabled = view != null;
-            SaveButton.IsEnabled = view != null;
-            SaveAsButton.IsEnabled = view != null;
-            CloseAllMenuItem.IsEnabled = view != null;
-            Title = view == null
-                ? "OpenNest (Avalonia prototype)"
-                : $"{view.Tab.Name} - OpenNest (Avalonia prototype)";
-            RebuildTabStrip();
-            UpdateViewToggles();
-            UpdateStatus();
-        }
-
-        private void RebuildTabStrip()
-        {
-            TabStrip.Children.Clear();
-            for (var i = 0; i < tabs.Tabs.Count; i++)
-                TabStrip.Children.Add(TabButton(tabs.Tabs[i], i == tabs.ActiveIndex));
-
-            var add = new Button
-            {
-                Content = "+",
-                FontSize = 15,
-                Padding = new Thickness(10, 2),
-                Margin = new Thickness(4, 4, 0, 0),
-                Background = Brushes.Transparent,
-                VerticalAlignment = VerticalAlignment.Top,
-            };
-            ToolTip.SetTip(add, "New nest");
-            add.Click += OnNew;
-            TabStrip.Children.Add(add);
-        }
-
-        private Control TabButton(NestTab tab, bool active)
-        {
-            var name = new TextBlock
-            {
-                Text = tab.Modified ? tab.Name + "  \u2022" : tab.Name,
-                FontSize = 13,
-                FontWeight = active ? FontWeight.SemiBold : FontWeight.Normal,
-                Foreground = active ? Brushes.Black : Muted,
-                VerticalAlignment = VerticalAlignment.Center,
-            };
-            var close = new Button
-            {
-                Content = "\u2715",
-                FontSize = 10,
-                Padding = new Thickness(5, 1),
-                Background = Brushes.Transparent,
-                Foreground = Muted,
-                VerticalAlignment = VerticalAlignment.Center,
-            };
-            ToolTip.SetTip(close, "Close");
-            close.Click += async (_, e) =>
-            {
-                e.Handled = true;
-                await CloseTabAsync(tab);
-            };
-
-            var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8 };
-            row.Children.Add(name);
-            row.Children.Add(close);
-            var border = new Border
-            {
-                Child = row,
-                Padding = new Thickness(14, 5, 6, 5),
-                Margin = new Thickness(0, 0, 2, 0),
-                CornerRadius = new CornerRadius(0, 0, 6, 6),
-                Background = active ? Brushes.White : InactiveTab,
-                BorderBrush = active ? Accent : Brushes.Transparent,
-                BorderThickness = new Thickness(0, 0, 0, 2),
-                Cursor = new Cursor(StandardCursorType.Hand),
-            };
-            ToolTip.SetTip(border, tab.Path);
-            border.PointerPressed += (_, e) =>
-            {
-                if (e.GetCurrentPoint(border).Properties.IsLeftButtonPressed)
-                    tabs.Activate(tabs.Tabs.ToList().IndexOf(tab));
-            };
-            return border;
-        }
-
-        private async Task<bool> CloseTabAsync(NestTab tab)
-        {
-            if (tab == nestingTab)
-            {
-                ShowNotice($"Auto Nest is running on {tab.Name}. Stop it before closing the nest.");
-                return false;
-            }
-            if (writingFile)
-            {
-                ShowNotice("A nest is being saved or exported. Close the nest once that finishes.");
-                return false;
-            }
-
-            if (!await ConfirmUnsavedAsync(tab))
-                return false;
-
-            tabs.Close(tab);
-            if (views.Remove(tab, out var closed))
-                SaveViewToggles(closed);
-            return true;
-        }
-
-        private async void OnCloseNest(object sender, RoutedEventArgs e)
-        {
-            if (tabs.Active != null)
-                await CloseTabAsync(tabs.Active);
-        }
-
-        private async void OnCloseAll(object sender, RoutedEventArgs e)
-        {
-            foreach (var tab in tabs.Tabs.Reverse().ToList())
-            {
-                if (!await CloseTabAsync(tab))
-                    return;
-            }
-        }
-
-        private async void OnWindowClosing(object sender, WindowClosingEventArgs e)
-        {
-            if (closeConfirmed || (!tabs.AnyModified && !writingFile))
-            {
-                nesting?.Cancel();
-                SaveAllViewToggles();
-                return;
-            }
-
-            e.Cancel = true;
-            if (askingToExit)
-                return;
-            if (writingFile)
-            {
-                ShowNotice("A nest is being saved or exported. Exit again once that finishes.");
-                return;
-            }
-
-            // As closing each WinForms nest window: ask about every unsaved nest in turn,
-            // showing it; Cancel, or a save that does not happen, keeps the app open. The list
-            // is read again after each answer: Auto Nest can finish while a question is open.
-            askingToExit = true;
-            try
-            {
-                var answered = new HashSet<NestTab>();
-                while (tabs.Tabs.FirstOrDefault(t => t.Modified && !answered.Contains(t))
-                    is { } tab)
-                {
-                    tabs.Activate(tabs.Tabs.ToList().IndexOf(tab));
-                    if (tab == nestingTab)
-                    {
-                        await ConfirmDialog.ShowAsync(this, "Exit OpenNest",
-                            $"Auto Nest is running on {tab.Name}, which has unsaved changes. "
-                            + "Stop Auto Nest (Nest > Stop Auto Nest) or let it finish, then "
-                            + "exit again.");
-                        return;
-                    }
-                    if (!await ConfirmUnsavedAsync(tab))
-                        return;
-                    answered.Add(tab);
-                }
-            }
-            finally
-            {
-                askingToExit = false;
-            }
-            closeConfirmed = true;
-            Close();
-        }
-
-        /// <summary>
-        /// For a nest with unsaved changes, asks Save / Don't Save / Cancel. True when it may
-        /// close: saved, or the user chose not to save.
-        /// </summary>
-        private async Task<bool> ConfirmUnsavedAsync(NestTab tab)
-        {
-            if (!tab.Modified)
-                return true;
-            var choice = await ConfirmDialog.ChooseAsync(this, "Unsaved Changes",
-                $"Save changes to '{tab.Name}' before closing?", "Save", "Don't Save");
-            return choice switch
-            {
-                0 => await SaveAsync(tab, askForFile: false),
-                1 => true,
-                _ => false,
-            };
-        }
-
-        private async void OnSave(object sender, RoutedEventArgs e)
-        {
-            if (tabs.Active != null)
-                await SaveAsync(tabs.Active, askForFile: false);
-        }
-
-        private async void OnSaveAs(object sender, RoutedEventArgs e)
-        {
-            if (tabs.Active != null)
-                await SaveAsync(tabs.Active, askForFile: true);
-        }
-
-        /// <summary>
-        /// Saves the nest to the file it was saved to this session, else (or for Save As) to a
-        /// file the user picks. True when it was saved.
-        /// </summary>
-        private async Task<bool> SaveAsync(NestTab tab, bool askForFile)
-        {
-            if (!CanWrite(tab, "saving"))
-                return false;
-            writingFile = true;
-            try
-            {
-                var path = askForFile ? null : tab.SavePath;
-                path ??= await PickNestFileAsync(tab, "Save Nest As");
-                // Auto Nest may have started on it while the file picker was open.
-                if (path == null || IsNesting(tab, "saving"))
-                    return false;
-                try
-                {
-                    tabs.SaveAs(tab, path);
-                }
-                catch (SaveTargetRefusedException ex)
-                {
-                    await ConfirmDialog.ShowAsync(
-                        this, "Save Nest", $"The nest was not saved. {ex.Message}");
-                    return false;
-                }
-                catch (Exception ex)
-                {
-                    await ConfirmDialog.ShowAsync(this, "Save Nest",
-                        "The nest was not saved. Any copy already at that path was left as it "
-                        + $"was.\n\n{path}\n\n{ex.Message}\n\nChoose File > Save As to save "
-                        + "it to another folder or name.");
-                    return false;
-                }
-                ShowNotice($"Saved {tab.Name} to {path}");
-                return true;
-            }
-            finally
-            {
-                writingFile = false;
-            }
-        }
-
-        private async void OnExportNest(object sender, RoutedEventArgs e)
-        {
-            var tab = tabs.Active;
-            if (tab == null || !CanWrite(tab, "exporting"))
-                return;
-            writingFile = true;
-            try
-            {
-                var path = await PickNestFileAsync(tab, "Save Copy as .nest File");
-                if (path == null || IsNesting(tab, "exporting"))
-                    return;
-                try
-                {
-                    // Export never changes the nest's file, name or unsaved mark.
-                    tabs.ExportCopy(tab, path);
-                    ShowNotice($"Saved a copy to {path}");
-                }
-                catch (SaveTargetRefusedException ex)
-                {
-                    await ConfirmDialog.ShowAsync(
-                        this, "Save Copy", $"The copy was not saved. {ex.Message}");
-                }
-                catch (Exception ex)
-                {
-                    await ConfirmDialog.ShowAsync(this, "Save Copy",
-                        $"The copy was not saved.\n\n{path}\n\n{ex.Message}\n\nChoose "
-                        + "File > Save Copy as .nest File again to pick another folder or name.");
-                }
-            }
-            finally
-            {
-                writingFile = false;
-            }
-        }
-
-        // Whether the tab's nest can be written now: not while Auto Nest works on it, and one
-        // save or export at a time.
-        private bool CanWrite(NestTab tab, string doing)
-        {
-            if (IsNesting(tab, doing))
-                return false;
-            if (writingFile)
-            {
-                ShowNotice("A nest is already being saved or exported. "
-                    + $"Finish that before {doing}.");
-                return false;
-            }
-            return true;
-        }
-
-        private bool IsNesting(NestTab tab, string doing)
-        {
-            if (tab != nestingTab)
-                return false;
-            ShowNotice($"Auto Nest is running on {tab.Name}. "
-                + $"Stop it or let it finish before {doing}.");
-            return true;
-        }
-
-        // A .nest file to write, named after the nest, starting in the folder of its file.
-        private async Task<string> PickNestFileAsync(NestTab tab, string title)
-        {
-            var folder = tab.Path != null ? Path.GetDirectoryName(tab.Path) : null;
-            var file = await StorageProvider.SaveFilePickerAsync(new FilePickerSaveOptions
-            {
-                Title = title,
-                SuggestedFileName = tab.Name,
-                DefaultExtension = "nest",
-                ShowOverwritePrompt = true,
-                FileTypeChoices = new[] { NestFiles },
-                SuggestedStartLocation = folder != null
-                    ? await StorageProvider.TryGetFolderFromPathAsync(folder)
-                    : null,
-            });
-            return file?.TryGetLocalPath();
-        }
-
-        private static readonly FilePickerFileType NestFiles =
-            new("Nest files") { Patterns = new[] { "*.nest" } };
-
-        // Shows the queued load warnings one dialog at a time, as WinForms does after each open.
-        private async Task ShowLoadWarningsAsync()
-        {
-            if (showingWarnings)
-                return;
-            showingWarnings = true;
-            try
-            {
-                while (pendingWarnings.TryDequeue(out var item))
-                    await ConfirmDialog.ShowAsync(this, "Nest Load Warnings",
-                        $"{item.Name}:\n\n" + string.Join(Environment.NewLine, item.Warnings));
-            }
-            finally
-            {
-                showingWarnings = false;
-            }
-        }
-
-        private void OnPreviewKeyDown(object sender, KeyEventArgs e)
-        {
-            if (e.Key == Key.Tab && e.KeyModifiers.HasFlag(KeyModifiers.Control))
-            {
-                StepNest(e.KeyModifiers.HasFlag(KeyModifiers.Shift) ? -1 : 1);
-                e.Handled = true;
-            }
-        }
-
-        private void OnNextNest(object sender, RoutedEventArgs e) => StepNest(1);
-
-        private void OnPreviousNest(object sender, RoutedEventArgs e) => StepNest(-1);
-
-        private void StepNest(int step)
-        {
-            var count = tabs.Tabs.Count;
-            if (count > 1)
-                tabs.Activate(((tabs.ActiveIndex + step) % count + count) % count);
-        }
-
-        private async void OnNew(object sender, RoutedEventArgs e) => await NewNestAsync();
-
         private async void OnOpen(object sender, RoutedEventArgs e)
         {
             var files = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
             {
                 Title = "Open Nest",
-                AllowMultiple = true,
+                AllowMultiple = false,
-                FileTypeFilter = new[] { NestFiles },
+                FileTypeFilter = new[] { new FilePickerFileType("Nest files") { Patterns = new[] { "*.nest" } } },
             });
-            foreach (var path in files.Select(f => f.TryGetLocalPath()).Where(p => p != null))
+            var path = files.FirstOrDefault()?.TryGetLocalPath();
+            if (path != null)
                 OpenNest(path);
         }
 
-        // As the WinForms main window: a drop is taken only when it holds a .nest file.
-        private void OnDragOver(object sender, DragEventArgs e)
-        {
-            e.DragEffects = DroppedNestFiles.Any(DroppedPaths(e))
-                ? DragDropEffects.Copy
-                : DragDropEffects.None;
-            e.Handled = true;
-        }
-
-        // Each dropped .nest file opens in a tab (or shows its tab); other files are ignored.
-        // As File > Open, this works while Auto Nest runs.
-        private void OnDrop(object sender, DragEventArgs e)
-        {
-            var paths = DroppedNestFiles.Select(DroppedPaths(e));
-            e.DragEffects = paths.Count > 0 ? DragDropEffects.Copy : DragDropEffects.None;
-            e.Handled = true;
-            foreach (var path in paths)
-                OpenNest(path);
-        }
-
-        private static IEnumerable<string> DroppedPaths(DragEventArgs e) =>
-            e.Data.GetFiles()?.Select(file => file.TryGetLocalPath())
-            ?? Enumerable.Empty<string>();
-
         private void OnExit(object sender, RoutedEventArgs e) => Close();
 
-        private void OnAutoNest(object sender, RoutedEventArgs e)
+        private void OnFit(object sender, RoutedEventArgs e) => Canvas.ZoomToFit();
-        {
-            // Stop always cancels and discards the whole proposal.
-            if (nesting != null)
-            {
-                nesting.Cancel();
-                return;
-            }
-            autoNest = RunAutoNestAsync();
-        }
-
-        /// <summary>
-        /// Nests every drawing's remaining quantity of the active nest on sheets like its shown
-        /// plate, through the shared pipeline off the UI thread. Other nests can be opened and
-        /// viewed meanwhile; the nest being nested cannot be closed until it finishes.
-        /// </summary>
-        private async Task RunAutoNestAsync()
-        {
-            var view = ActiveView;
-            if (view == null || nesting != null)
-                return;
-            var tab = view.Tab;
-            var nest = tab.Document.Nest;
-            var engineName = EngineSelection.EngineName;
-            var template = view.PlateView.Plate
-                ?? nest.Plates.FirstOrDefault()
-                ?? nest.PlateDefaults.CreateNew();
-            var request = AutoNestJob.ForRemaining(nest, template, engineName);
-            if (request == null)
-            {
-                ShowNotice("Auto Nest: nothing has a remaining quantity to nest.");
-                return;
-            }
-
-            nesting = new CancellationTokenSource();
-            nestingTab = tab;
-            var token = nesting.Token;
-            SetNesting(true);
-            ShowNotice($"{engineName}: starting...");
-            var progress = new Progress<NestProgress>(p =>
-            {
-                if (!token.IsCancellationRequested)
-                    ShowNotice(p.Description ?? $"{engineName}: plate {p.PlateNumber}");
-            });
-            try
-            {
-                var jobProgress = JobEngineNest.CreateProgress(engineName, progress);
-                var result = await Task.Run(() => NestPipeline.Run(request, jobProgress, token));
-                // Engines that ignore cancellation still have their proposal discarded.
-                token.ThrowIfCancellationRequested();
-                var firstNew = nest.Plates.Count(p => p.Parts.Count > 0);
-                var kept = AutoNestJob.Keep(nest, result);
-                if (kept.Nested)
-                {
-                    tab.MarkModified();
-                    view.Refresh(firstNew);
-                    RebuildTabStrip();
-                }
-                ShowNotice(kept.Nested
-                    ? $"{tab.Name}: {engineName}: {kept.Note}"
-                    : AutoNestJob.RefusalReason(result));
-            }
-            catch (OperationCanceledException) when (token.IsCancellationRequested)
-            {
-                ShowNotice("Auto Nest stopped; nothing was changed.");
-            }
-            catch (Exception ex)
-            {
-                ShowNotice($"Auto Nest failed: {ex.Message}");
-            }
-            finally
-            {
-                nesting.Dispose();
-                nesting = null;
-                nestingTab = null;
-                SetNesting(false);
-            }
-        }
-
-        private void SetNesting(bool running)
-        {
-            AutoNestButton.Content = running ? "Stop" : "Auto Nest";
-            AutoNestMenuItem.Header = running ? "_Stop Auto Nest" : "_Auto Nest";
-        }
-
-        /// <summary>Completes once the machines are read (see <see cref="DesktopSettings.LoadMachinesAsync"/>).</summary>
-        internal Task MachinesLoaded { get; }
-
-        private async Task LoadMachinesAsync()
-        {
-            string warning;
-            try
-            {
-                warning = await DesktopSettings.LoadMachinesAsync();
-            }
-            catch (Exception ex)
-            {
-                warning = $"The machines could not be read: {ex.Message}";
-            }
-            if (warning != null)
-                ShowNotice(warning);
-        }
-
-        private void ShowNotice(string text)
-        {
-            notice = text;
-            UpdateStatus();
-        }
-
-        private void OnFit(object sender, RoutedEventArgs e) => ActiveView?.PlateView.ZoomToFit();
 
         private void OnPreviousPlate(object sender, RoutedEventArgs e) => StepPlate(-1);
 
         private void OnNextPlate(object sender, RoutedEventArgs e) => StepPlate(1);
 
-        private void StepPlate(int step) => ActiveView?.StepPlate(step);
+        private void StepPlate(int step)
+        {
+            if (nest == null || nest.Plates.Count == 0)
+                return;
+            PlateList.SelectedIndex = System.Math.Clamp(PlateList.SelectedIndex + step, 0, nest.Plates.Count - 1);
+        }
+
+        private void OnPlateSelected(object sender, SelectionChangedEventArgs e)
+        {
+            var index = PlateList.SelectedIndex;
+            var plate = nest != null && index >= 0 ? nest.Plates[index] : null;
+            Canvas.Plate = plate;
+            DrawingGrid.ItemsSource = plate?.Parts
+                .Where(part => !part.BaseDrawing.IsCutOff)
+                .GroupBy(part => part.BaseDrawing)
+                .Select(group => new DrawingRow(group.Key.Name, group.Count(), SizeOf(group.First())))
+                .OrderByDescending(row => row.Count)
+                .ToList();
+            UpdateStatus();
+        }
+
+        private static string SizeOf(Part part) =>
+            $"{part.BoundingBox.Length:0.###} x {part.BoundingBox.Width:0.###}";
 
         private void UpdateStatus()
         {
-            var view = ActiveView;
+            if (Canvas.Plate == null)
-            var canvas = view?.PlateView;
-            if (canvas?.Plate == null)
-            {
-                var empty = view == null
-                    ? "Create a new nest or open a .nest file to begin."
-                    : $"{view.Tab.Name}   No plates";
-                Status.Text = notice ?? empty;
                 return;
-            }
+            var text = $"{fileName}   Plate {PlateList.SelectedIndex + 1} of {nest.Plates.Count}   Zoom {Canvas.Zoom:0.##} px/unit";
-
+            if (Canvas.CursorWorld is { } at)
-            var text = $"{view.Tab.Name}   Plate {view.PlateIndex + 1} of {view.PlateCount}"
-                + $"   Zoom {canvas.Zoom:0.##} px/unit";
-            if (canvas.CursorWorld is { } at)
                 text += $"   X {at.X:0.000}  Y {at.Y:0.000}";
-            var part = canvas.HoveredPart ?? canvas.SelectedPart;
+            var part = Canvas.HoveredPart ?? Canvas.SelectedPart;
             if (part != null)
-            {
+                text += $"   {(ReferenceEquals(part, Canvas.SelectedPart) ? "Selected" : "Over")}: {part.BaseDrawing.Name}";
-                var how = ReferenceEquals(part, canvas.SelectedPart) ? "Selected" : "Over";
-                text += $"   {how}: {part.BaseDrawing.Name}";
-            }
-            if (notice != null)
-                text += $"   |   {notice}";
             Status.Text = text;
         }
 

OpenNest.Avalonia/NestView.axaml

@@ -1,41 +0,0 @@
-<UserControl xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:c="using:OpenNest.Avalonia.Controls"
-             xmlns:local="using:OpenNest.Avalonia"
-             x:Class="OpenNest.Avalonia.NestView">
-  <Grid ColumnDefinitions="290,4,*">
-    <Border Grid.Column="0" Background="White">
-      <TabControl x:Name="SideTabs" Padding="0">
-        <TabItem Header="Plates" FontSize="14" MinHeight="34">
-          <ListBox x:Name="PlateList" SelectionChanged="OnPlateSelected" />
-        </TabItem>
-        <TabItem Header="Drawings" FontSize="14" MinHeight="34">
-          <DataGrid x:Name="DrawingGrid" x:DataType="local:DrawingRow" IsReadOnly="True"
-                    FontSize="13" AutoGenerateColumns="False"
-                    GridLinesVisibility="Horizontal" CanUserSortColumns="True">
-            <DataGrid.Columns>
-              <DataGridTextColumn Header="Drawing" Binding="{Binding Name}" Width="*" />
-              <DataGridTextColumn Header="Nested" Binding="{Binding Nested}" />
-              <DataGridTextColumn Header="Required" Binding="{Binding Required}" />
-            </DataGrid.Columns>
-          </DataGrid>
-        </TabItem>
-      </TabControl>
-    </Border>
-    <GridSplitter Grid.Column="1" ResizeDirection="Columns" Background="#D0D4D8" />
-    <DockPanel Grid.Column="2">
-      <Border DockPanel.Dock="Top" Padding="8,4" Background="White"
-              BorderBrush="#D0D4D8" BorderThickness="0,0,0,1">
-        <StackPanel Orientation="Horizontal" Spacing="6">
-          <Button Content="&#x23EE;" ToolTip.Tip="First plate" Click="OnFirstPlate" />
-          <Button Content="&#x25C0;" ToolTip.Tip="Previous plate (Page Up)"
-                  Click="OnPreviousPlate" />
-          <TextBlock x:Name="PlateLabel" VerticalAlignment="Center" FontSize="13" Margin="6,0" />
-          <Button Content="&#x25B6;" ToolTip.Tip="Next plate (Page Down)" Click="OnNextPlate" />
-          <Button Content="&#x23ED;" ToolTip.Tip="Last plate" Click="OnLastPlate" />
-        </StackPanel>
-      </Border>
-      <c:PlateCanvas x:Name="Canvas" />
-    </DockPanel>
-  </Grid>
-</UserControl>

OpenNest.Avalonia/NestView.axaml.cs

@@ -1,99 +0,0 @@
-using System;
-using System.Linq;
-using Avalonia.Controls;
-using Avalonia.Interactivity;
-using OpenNest.Avalonia.Controls;
-using OpenNest.Desktop;
-
-namespace OpenNest.Avalonia
-{
-    public sealed record DrawingRow(string Name, int Nested, int Required);
-
-    /// <summary>
-    /// One open nest: Plates and Drawings tabs on the left, the plate header and plate view on
-    /// the right. Each tab keeps its own view, so switching nests keeps each one's plate and zoom.
-    /// </summary>
-    public partial class NestView : UserControl
-    {
-        public NestView()
-        {
-            InitializeComponent();
-        }
-
-        public NestView(NestTab tab)
-            : this()
-        {
-            Tab = tab;
-            Canvas.ViewChanged += (_, _) => ViewChanged?.Invoke(this, EventArgs.Empty);
-            Refresh(0);
-        }
-
-        /// <summary>Raised when the shown plate, zoom, hover or selection changes.</summary>
-        public event EventHandler ViewChanged;
-
-        public NestTab Tab { get; }
-
-        public PlateCanvas PlateView => Canvas;
-
-        public int PlateIndex => PlateList.SelectedIndex;
-
-        public int PlateCount => Tab.Document.Nest.Plates.Count;
-
-        /// <summary>Rebuilds both lists and shows plate <paramref name="selectIndex"/>.</summary>
-        public void Refresh(int selectIndex)
-        {
-            var nest = Tab.Document.Nest;
-            // As the WinForms nest window: one empty plate stays at the end to nest onto, so a
-            // new nest shows Plate 1. Files leave empty plates out, so saving is unchanged.
-            using (var plates = new PlateManager(nest))
-                plates.EnsureSentinel();
-            Canvas.ClearCache();
-            PlateList.ItemsSource = nest.Plates
-                .Select((plate, i) =>
-                    $"Plate {i + 1}   {SizeText(plate)}   ({plate.Parts.Count} parts)")
-                .ToList();
-            PlateList.SelectedIndex = nest.Plates.Count > 0
-                ? System.Math.Clamp(selectIndex, 0, nest.Plates.Count - 1)
-                : -1;
-            DrawingGrid.ItemsSource = nest.Drawings
-                .Where(d => !d.IsCutOff)
-                .Select(d => new DrawingRow(d.Name, d.Quantity.Nested, d.Quantity.Required))
-                .ToList();
-            ShowPlate();
-        }
-
-        public void ShowPlate(int index)
-        {
-            if (PlateCount > 0)
-                PlateList.SelectedIndex = System.Math.Clamp(index, 0, PlateCount - 1);
-        }
-
-        public void StepPlate(int step) => ShowPlate(PlateList.SelectedIndex + step);
-
-        private void OnPlateSelected(object sender, SelectionChangedEventArgs e) => ShowPlate();
-
-        private void ShowPlate()
-        {
-            var nest = Tab.Document.Nest;
-            var index = PlateList.SelectedIndex;
-            var plate = index >= 0 && index < nest.Plates.Count ? nest.Plates[index] : null;
-            Canvas.Plate = plate;
-            PlateLabel.Text = plate == null
-                ? "No plates"
-                : $"Plate {index + 1} of {nest.Plates.Count}    "
-                    + $"{SizeText(plate)}    qty {plate.Quantity}";
-            ViewChanged?.Invoke(this, EventArgs.Empty);
-        }
-
-        private static string SizeText(Plate plate) =>
-            $"{plate.Size.Length:0.###} x {plate.Size.Width:0.###}";
-
-        private void OnFirstPlate(object sender, RoutedEventArgs e) => ShowPlate(0);
-
-        private void OnPreviousPlate(object sender, RoutedEventArgs e) => StepPlate(-1);
-
-        private void OnNextPlate(object sender, RoutedEventArgs e) => StepPlate(1);
-
-        private void OnLastPlate(object sender, RoutedEventArgs e) => ShowPlate(PlateCount - 1);
-    }
-}

OpenNest.Avalonia/OpenNest.Avalonia.csproj

@@ -11,34 +11,10 @@
   <ItemGroup>
     <ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />
     <ProjectReference Include="..\OpenNest.IO\OpenNest.IO.csproj" />
-    <ProjectReference Include="..\OpenNest.Desktop\OpenNest.Desktop.csproj" />
     <PackageReference Include="Avalonia" Version="11.3.0" />
     <PackageReference Include="Avalonia.Desktop" Version="11.3.0" />
     <PackageReference Include="Avalonia.Themes.Fluent" Version="11.3.0" />
     <PackageReference Include="Avalonia.Fonts.Inter" Version="11.3.0" />
     <PackageReference Include="Avalonia.Controls.DataGrid" Version="11.3.0" />
   </ItemGroup>
-  <ItemGroup>
-    <!-- The WinForms app's empty-workspace logo, shared rather than copied. -->
-    <AvaloniaResource Include="..\OpenNest\Resources\watermark.png" Link="Assets\watermark.png" />
-  </ItemGroup>
-  <ItemGroup>
-    <!-- The posts the WinForms app ships, built with this app and copied to its Posts/ directory. -->
-    <ProjectReference Include="..\Posts\OpenNest.Posts.Cincinnati\OpenNest.Posts.Cincinnati.csproj" ReferenceOutputAssembly="false" IsPost="true" />
-    <ProjectReference Include="..\Posts\OpenNest.Posts.CincinnatiCIFiber\OpenNest.Posts.CincinnatiCIFiber.csproj" ReferenceOutputAssembly="false" IsPost="true" />
-  </ItemGroup>
-  <!-- As for the WinForms app: each post DLL, and its shipped settings JSON unless one is already
-       deployed (an edited copy is kept), go to Posts/ beside the app, which loads them at startup. -->
-  <Target Name="CopyPostsToOutput" AfterTargets="Build">
-    <MSBuild Projects="@(ProjectReference)" Condition="'%(ProjectReference.IsPost)' == 'true'" Targets="GetTargetPath">
-      <Output TaskParameter="TargetOutputs" ItemName="PostAssembly" />
-    </MSBuild>
-    <ItemGroup>
-      <PostConfig Include="@(PostAssembly->'%(RootDir)%(Directory)%(Filename).json')" />
-      <PostConfigToCopy Include="@(PostConfig)" Condition="Exists('%(FullPath)') and !Exists('$(OutDir)Posts\%(Filename)%(Extension)')" />
-    </ItemGroup>
-    <MakeDir Directories="$(OutDir)Posts" />
-    <Copy SourceFiles="@(PostAssembly)" DestinationFolder="$(OutDir)Posts" SkipUnchangedFiles="true" />
-    <Copy SourceFiles="@(PostConfigToCopy)" DestinationFolder="$(OutDir)Posts" SkipUnchangedFiles="true" />
-  </Target>
 </Project>

OpenNest.Avalonia/Rendering/ProgramPaths.cs

@@ -0,0 +1,175 @@
+using System;
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using OpenNest.Math;
+using SkiaSharp;
+
+namespace OpenNest.Avalonia.Rendering
+{
+    /// <summary>
+    /// A program's display geometry as Skia paths in the program frame, before placement.
+    /// A Skia port of the desktop's GraphicsHelper.GetDisplayPaths, without tab bridging.
+    /// </summary>
+    internal sealed class ProgramPaths : IDisposable
+    {
+        public SKPath Cut { get; } = new() { FillType = SKPathFillType.EvenOdd };
+
+        public SKPath Lead { get; } = new();
+
+        public SKPath Etch { get; } = new();
+
+        /// <summary>The material outline to fill: cuts and tabs, without open break cuts.</summary>
+        public SKPath Fill { get; } = new() { FillType = SKPathFillType.EvenOdd };
+
+        public SKRect Bounds { get; private set; }
+
+        public static ProgramPaths Build(CNC.Program program)
+        {
+            var paths = new ProgramPaths();
+            var position = Vector.Zero;
+            paths.AddProgram(program, ref position);
+            var bounds = paths.Cut.Bounds;
+            if (!paths.Etch.IsEmpty)
+                bounds = paths.Cut.IsEmpty ? paths.Etch.Bounds : SKRect.Union(bounds, paths.Etch.Bounds);
+            paths.Bounds = bounds;
+            return paths;
+        }
+
+        private SKPath TargetFor(LayerType layer) => layer switch
+        {
+            LayerType.Leadin or LayerType.Leadout => Lead,
+            LayerType.Scribe => Etch,
+            LayerType.Display or LayerType.Tab => null,
+            _ => Cut,
+        };
+
+        private void AddProgram(CNC.Program program, ref Vector position)
+        {
+            // Sub-program offsets are relative to the frame origin at entry, not the tool position.
+            var frameOrigin = position;
+            var mode = program.Mode;
+            SKPath open = null;
+
+            for (var i = 0; i < program.Length; ++i)
+            {
+                var code = program[i];
+                switch (code)
+                {
+                    case LinearMove line:
+                        {
+                            var end = mode == Mode.Incremental ? line.EndPoint + position : line.EndPoint;
+                            var target = line.Suppressed ? null : TargetFor(line.Layer);
+                            if (target != null)
+                            {
+                                Continue(ref open, target, position);
+                                target.LineTo((float)end.X, (float)end.Y);
+                            }
+                            if (!line.Suppressed && line.Layer != LayerType.Break)
+                                AddFillLine(line.Layer, position, end);
+                            position = end;
+                            break;
+                        }
+
+                    case ArcMove arc:
+                        {
+                            var end = arc.EndPoint;
+                            var center = arc.CenterPoint;
+                            if (mode == Mode.Incremental)
+                            {
+                                end += position;
+                                center += position;
+                            }
+                            var target = arc.Suppressed ? null : TargetFor(arc.Layer);
+                            if (target != null)
+                            {
+                                Continue(ref open, target, position);
+                                AddArc(target, position, end, center, arc.Rotation);
+                            }
+                            if (!arc.Suppressed && arc.Layer != LayerType.Break)
+                                AddFillArc(arc.Layer, position, end, center, arc.Rotation);
+                            position = end;
+                            break;
+                        }
+
+                    case RapidMove rapid:
+                        {
+                            var end = mode == Mode.Incremental ? rapid.EndPoint + position : rapid.EndPoint;
+                            if (end.DistanceTo(position) > 0.001)
+                                open = null;
+                            position = end;
+                            break;
+                        }
+
+                    case SubProgramCall call when call.Program != null:
+                        open = null;
+                        position = new Vector(frameOrigin.X + call.Offset.X, frameOrigin.Y + call.Offset.Y);
+                        AddProgram(call.Program, ref position);
+                        open = null;
+                        break;
+                }
+            }
+        }
+
+        // Starts a new contour unless the move continues the one already open on the same path.
+        private SKPath openFill;
+
+        private static void Continue(ref SKPath open, SKPath target, Vector from)
+        {
+            if (!ReferenceEquals(open, target) || target.LastPoint != new SKPoint((float)from.X, (float)from.Y))
+                target.MoveTo((float)from.X, (float)from.Y);
+            open = target;
+        }
+
+        private bool IsMaterial(LayerType layer) =>
+            layer is not (LayerType.Scribe or LayerType.Leadin or LayerType.Leadout or LayerType.Display);
+
+        private void AddFillLine(LayerType layer, Vector from, Vector to)
+        {
+            if (!IsMaterial(layer))
+                return;
+            Continue(ref openFill, Fill, from);
+            Fill.LineTo((float)to.X, (float)to.Y);
+        }
+
+        private void AddFillArc(LayerType layer, Vector from, Vector to, Vector center, RotationType rotation)
+        {
+            if (!IsMaterial(layer))
+                return;
+            Continue(ref openFill, Fill, from);
+            AddArc(Fill, from, to, center, rotation);
+        }
+
+        private static void AddArc(SKPath path, Vector from, Vector to, Vector center, RotationType rotation)
+        {
+            var startAngle = Angle.NormalizeDeg(Angle.ToDegrees(System.Math.Atan2(from.Y - center.Y, from.X - center.X)));
+            var endAngle = Angle.NormalizeDeg(Angle.ToDegrees(System.Math.Atan2(to.Y - center.Y, to.X - center.X)));
+            var radius = (float)center.DistanceTo(to);
+            var oval = new SKRect((float)center.X - radius, (float)center.Y - radius,
+                (float)center.X + radius, (float)center.Y + radius);
+
+            if (startAngle.IsEqualTo(endAngle))
+            {
+                // A full circle: two half sweeps keep the contour starting at the current point.
+                var sweep = rotation == RotationType.CCW ? 180f : -180f;
+                path.ArcTo(oval, (float)startAngle, sweep, false);
+                path.ArcTo(oval, (float)startAngle + sweep, sweep, false);
+                return;
+            }
+
+            if (rotation == RotationType.CCW && endAngle < startAngle)
+                endAngle += 360.0;
+            else if (rotation == RotationType.CW && startAngle < endAngle)
+                startAngle += 360.0;
+
+            path.ArcTo(oval, (float)startAngle, (float)(endAngle - startAngle), false);
+        }
+
+        public void Dispose()
+        {
+            Cut.Dispose();
+            Lead.Dispose();
+            Etch.Dispose();
+            Fill.Dispose();
+        }
+    }
+}

OpenNest.Avalonia/Rendering/SkiaFigures.cs

@@ -1,107 +0,0 @@
-using System.Collections.Generic;
-using OpenNest.Desktop.Rendering;
-using OpenNest.Geometry;
-using SkiaSharp;
-
-namespace OpenNest.Avalonia.Rendering
-{
-    /// <summary>Converts the shared plate-view figures to Skia paths.</summary>
-    internal static class SkiaFigures
-    {
-        public static SKPath ToPath(IEnumerable<PathFigure> figures, SKPathFillType fillType = SKPathFillType.EvenOdd)
-        {
-            var path = new SKPath { FillType = fillType };
-            foreach (var figure in figures)
-                Add(path, figure);
-            return path;
-        }
-
-        public static void Add(SKPath path, PathFigure figure)
-        {
-            path.MoveTo((float)figure.Start.X, (float)figure.Start.Y);
-            foreach (var segment in figure.Segments)
-            {
-                switch (segment)
-                {
-                    case LineTo line:
-                        path.LineTo((float)line.End.X, (float)line.End.Y);
-                        break;
-
-                    case ArcTo arc:
-                        {
-                            var r = (float)arc.Radius;
-                            var oval = new SKRect((float)arc.Center.X - r, (float)arc.Center.Y - r,
-                                (float)arc.Center.X + r, (float)arc.Center.Y + r);
-                            if (arc.IsFullCircle)
-                            {
-                                // Skia drops a whole-turn sweep; two halves keep the contour joined.
-                                var half = (float)(arc.SweepAngle / 2);
-                                path.ArcTo(oval, (float)arc.StartAngle, half, false);
-                                path.ArcTo(oval, (float)arc.StartAngle + half, half, false);
-                            }
-                            else
-                                path.ArcTo(oval, (float)arc.StartAngle, (float)arc.SweepAngle, false);
-                            break;
-                        }
-                }
-            }
-            if (figure.IsClosed && figure.Segments.Count > 0)
-                path.Close();
-        }
-
-        public static SKPath Polygons(IEnumerable<IReadOnlyList<Vector>> polygons)
-        {
-            var path = new SKPath { FillType = SKPathFillType.EvenOdd };
-            foreach (var points in polygons)
-            {
-                if (points.Count == 0)
-                    continue;
-                path.MoveTo((float)points[0].X, (float)points[0].Y);
-                for (var i = 1; i < points.Count; i++)
-                    path.LineTo((float)points[i].X, (float)points[i].Y);
-                path.Close();
-            }
-            return path;
-        }
-    }
-
-    /// <summary>
-    /// A part's shared display geometry as Skia paths in its program frame, before placement.
-    /// Built on the UI thread and only read afterwards, so the render thread may draw it.
-    /// </summary>
-    internal sealed class PartPaths
-    {
-        private PartPaths(PartDisplayGeometry geometry)
-        {
-            Geometry = geometry;
-            Cut = SkiaFigures.ToPath(geometry.Cut);
-            Lead = SkiaFigures.ToPath(geometry.Lead);
-            Etch = SkiaFigures.ToPath(geometry.Etch);
-            Material = SkiaFigures.ToPath(geometry.Material);
-            Display = geometry.Display.Count > 0 ? SkiaFigures.ToPath(geometry.Display) : null;
-            Selection = geometry.Cut.Count > 0 ? Material : Etch;
-            StrokeBounds = geometry.StrokeBounds();
-        }
-
-        public PartDisplayGeometry Geometry { get; }
-
-        public SKPath Cut { get; }
-
-        public SKPath Lead { get; }
-
-        public SKPath Etch { get; }
-
-        public SKPath Material { get; }
-
-        /// <summary>Display-only geometry; null when the drawing has none.</summary>
-        public SKPath Display { get; }
-
-        /// <summary>What picks the part: its material, or an etch-only part's marks.</summary>
-        public SKPath Selection { get; }
-
-        /// <summary>The bounds of every stroke in the program frame; null when nothing is drawn.</summary>
-        public Box StrokeBounds { get; }
-
-        public static PartPaths Build(Part part) => new(PartDisplayGeometry.Build(part));
-    }
-}

OpenNest.Avalonia/Rendering/SkiaSchemePalette.cs

@@ -1,88 +0,0 @@
-using System.Collections.Concurrent;
-using System.Runtime.CompilerServices;
-using SkiaSharp;
-using DrawingColor = System.Drawing.Color;
-
-namespace OpenNest.Avalonia.Rendering
-{
-    /// <summary>
-    /// A colour scheme's colours as Skia colours, for the plate canvas. Immutable, so the render
-    /// thread may read one while the UI thread changes the scheme; <see cref="For"/> returns the
-    /// cached palette until the scheme's colours change.
-    /// </summary>
-    internal sealed class SkiaSchemePalette
-    {
-        // The WinForms view's translucent selection fill, used when the scheme sets none.
-        private static readonly DrawingColor LegacySelectedColor = DrawingColor.FromArgb(90, 150, 200, 255);
-
-        private static readonly ConditionalWeakTable<ColorScheme, SkiaSchemePalette> Cache = new();
-
-        private readonly DrawingColor partOutline;
-        private readonly ConcurrentDictionary<SKColor, SKColor> outlines = new();
-
-        private SkiaSchemePalette(ColorScheme scheme)
-        {
-            partOutline = scheme.PartOutlineColor;
-            Version = scheme.Version;
-            Background = ToSk(scheme.BackgroundColor);
-            PlateFill = ToSk(scheme.LayoutFillColor);
-            PlateOutline = ToSk(scheme.LayoutOutlineColor);
-            EdgeSpacing = ToSk(scheme.EdgeSpacingColor);
-            Etch = ToSk(scheme.EtchColor);
-            Origin = ToSk(scheme.OriginColor);
-            Rapid = ToSk(scheme.RapidColor);
-            BoundingBox = ToSk(scheme.BoundingBoxColor);
-            var selected = scheme.SelectedPartColor.IsEmpty ? LegacySelectedColor : scheme.SelectedPartColor;
-            SelectedFill = ToSk(selected);
-            // As WinForms: the scheme's outline, else the legacy selection fill darkened.
-            SelectedOutline = ToSk(scheme.PartOutlineColor.IsEmpty
-                ? ColorShade.Dark(LegacySelectedColor)
-                : scheme.PartOutlineColor);
-        }
-
-        private int Version { get; }
-
-        public SKColor Background { get; }
-
-        public SKColor PlateFill { get; }
-
-        public SKColor PlateOutline { get; }
-
-        public SKColor EdgeSpacing { get; }
-
-        public SKColor Etch { get; }
-
-        public SKColor Origin { get; }
-
-        public SKColor Rapid { get; }
-
-        public SKColor BoundingBox { get; }
-
-        public SKColor SelectedFill { get; }
-
-        public SKColor SelectedOutline { get; }
-
-        /// <summary>The palette for <paramref name="scheme"/>'s current colours.</summary>
-        public static SkiaSchemePalette For(ColorScheme scheme)
-        {
-            lock (Cache)
-            {
-                if (!Cache.TryGetValue(scheme, out var palette) || palette.Version != scheme.Version)
-                {
-                    palette = new SkiaSchemePalette(scheme);
-                    Cache.AddOrUpdate(scheme, palette);
-                }
-
-                return palette;
-            }
-        }
-
-        /// <summary>A part's outline for its fill: the scheme's outline colour, or the fill darkened.</summary>
-        public SKColor PartOutline(SKColor fill) =>
-            outlines.GetOrAdd(fill, f => ToSk(partOutline.IsEmpty
-                ? ColorShade.Dark(DrawingColor.FromArgb(f.Alpha, f.Red, f.Green, f.Blue))
-                : partOutline));
-
-        public static SKColor ToSk(DrawingColor color) => new(color.R, color.G, color.B, color.A);
-    }
-}

OpenNest.Avalonia/WindowPlacementBinding.cs

@@ -1,111 +0,0 @@
-using System;
-using System.Linq;
-using Avalonia;
-using Avalonia.Controls;
-using OpenNest.Data;
-using OpenNest.Desktop;
-
-namespace OpenNest.Avalonia
-{
-    /// <summary>
-    /// Restores a window's size, position and maximized state from the shared user-settings
-    /// file and saves them when it closes, under the same names the WinForms app uses.
-    /// </summary>
-    /// <remarks>
-    /// Sizes are stored in screen pixels. Avalonia sets the client area, while WinForms stores
-    /// the outer window, so a size saved by one app opens a frame's width different in the
-    /// other; each app's own round trip is exact.
-    /// </remarks>
-    internal sealed class WindowPlacementBinding
-    {
-        private readonly Window window;
-        private readonly string name;
-        private readonly string settingsPath;
-        private PixelPoint? normalPosition;
-        private (int Width, int Height)? normalSize;
-
-        private WindowPlacementBinding(Window window, string name, string settingsPath)
-        {
-            this.window = window;
-            this.name = name;
-            this.settingsPath = settingsPath;
-        }
-
-        /// <summary>Call before the window is shown.</summary>
-        public static void Remember(Window window, string name, string settingsPath)
-        {
-            var binding = new WindowPlacementBinding(window, name, settingsPath);
-            binding.Restore();
-            window.Opened += (_, _) => binding.Track();
-            window.PositionChanged += (_, _) => binding.Track();
-            window.PropertyChanged += (_, e) =>
-            {
-                if (e.Property == TopLevel.ClientSizeProperty
-                    || e.Property == Window.WindowStateProperty)
-                    binding.Track();
-            };
-            window.Closing += (_, _) => binding.Save();
-        }
-
-        private void Restore()
-        {
-            var saved = WindowPlacement.Read(UserSettingsFile.Read(settingsPath), name);
-            var screens = window.Screens?.All;
-            if (saved == null || screens == null)
-                return;
-
-            var areas = screens
-                .Select(s => s.WorkingArea)
-                .Select(a => new OpenNest.Desktop.PixelRect(a.X, a.Y, a.Width, a.Height))
-                .ToList();
-            var placement = saved.FitTo(areas);
-            var screen = placement.Location is { } at
-                ? screens.First(s => s.WorkingArea.Contains(new PixelPoint(at.X, at.Y)))
-                : screens.FirstOrDefault(s => s.IsPrimary) ?? screens.FirstOrDefault();
-
-            if (placement.Location is { } location)
-            {
-                window.WindowStartupLocation = WindowStartupLocation.Manual;
-                window.Position = new PixelPoint(location.X, location.Y);
-            }
-
-            if (placement.Size is { } size)
-            {
-                var scaling = screen?.Scaling ?? 1;
-                window.Width = size.Width / scaling;
-                window.Height = size.Height / scaling;
-            }
-
-            if (placement.Maximized)
-                window.WindowState = WindowState.Maximized;
-        }
-
-        /// <summary>Remembers the normal bounds, which maximizing keeps.</summary>
-        private void Track()
-        {
-            if (window.WindowState != WindowState.Normal || !window.IsVisible)
-                return;
-
-            normalPosition = window.Position;
-            var scaling = window.DesktopScaling;
-            normalSize = ((int)System.Math.Round(window.ClientSize.Width * scaling),
-                (int)System.Math.Round(window.ClientSize.Height * scaling));
-        }
-
-        private void Save()
-        {
-            Track();
-            var maximized = window.WindowState == WindowState.Maximized;
-            UserSettingsFile.Update(settingsPath, values =>
-            {
-                // A window never shown normal this session keeps the bounds saved before.
-                var previous = WindowPlacement.Read(values, name);
-                var placement = new WindowPlacement(
-                    normalPosition is { } p ? (p.X, p.Y) : previous?.Location,
-                    normalSize ?? previous?.Size,
-                    maximized);
-                placement.WriteTo(values, name);
-            });
-        }
-    }
-}

OpenNest.Benchmark/BenchmarkJob.cs

@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using OpenNest.Clamps;
-using OpenNest.CutOffs;
 using OpenNest.Engine.Jobs;
 using OpenNest.Engine.Jobs.Adapters;
 using OpenNest.Geometry;
@@ -49,10 +47,6 @@ namespace OpenNest.Benchmark
         /// <summary>Saved source-nest setting; manifests have no saved salvage rate and use zero.</summary>
         public double SalvageRate { get; init; }
 
-        /// <summary>Manifest "offcutCut": which edge strips count as a sheet's offcut;
-        /// null for all.</summary>
-        public CutOffAxis? OffcutCut { get; init; }
-
         /// <summary>Original hand-authored placements, if the source was a .nest with any real parts.</summary>
         public List<(Plate Plate, List<Part> Parts)> BaselinePlateRuns { get; init; }
         public List<DrawingRequest> Requests { get; init; }
@@ -96,11 +90,10 @@ namespace OpenNest.Benchmark
                 parts,
                 stock,
                 new NestJobOptions(
-                    "Lattice",
+                    "Fill",
                     maxPlates,
                     salvageRate ?? SalvageRate,
-                    minimumSalvageDimension ?? 0,
+                    minimumSalvageDimension ?? 0
-                    offcutCut: OffcutCut
                 )
             );
         }

OpenNest.Benchmark/BenchmarkRunner.cs

@@ -8,7 +8,6 @@ using System.Threading.Tasks;
 using OpenNest.Engine.BestFit;
 using OpenNest.Engine.Jobs;
 using OpenNest.Engine.Jobs.Adapters;
-using OpenNest.Engine.NestingEngines;
 
 namespace OpenNest.Benchmark
 {
@@ -29,15 +28,6 @@ namespace OpenNest.Benchmark
         /// <summary>Wall-clock budget for one engine solving one job.</summary>
         private static readonly TimeSpan SolveTimeout = TimeSpan.FromMinutes(5);
 
-        /// <summary>How long past a --time-limit the harness waits before abandoning a solve.
-        /// </summary>
-        private static readonly TimeSpan TimeLimitGrace = TimeSpan.FromMinutes(1);
-
-        /// <summary>The longest --time-limit: the harness timeout above it must still fit a
-        /// cancellation timer.</summary>
-        internal static readonly TimeSpan MaxTimeLimit =
-            DeadlineNestingEngine.MaxLimit - TimeLimitGrace;
-
         public static List<JobResult> Run(
             List<BenchmarkJob> jobs,
             IReadOnlyList<NestingEngineInfo> engines,
@@ -45,9 +35,7 @@ namespace OpenNest.Benchmark
             double? minimumSalvageDimension = null,
             string outputDirectory = null,
             int maxParallelism = 1,
-            System.IO.TextWriter progressLog = null,
+            System.IO.TextWriter progressLog = null
-            TimeSpan? timeLimit = null,
-            CommonLineSetting commonLines = null
         )
         {
             var pairs = jobs.SelectMany(job => engines.Select(engine => (Job: job, Engine: engine)))
@@ -83,9 +71,7 @@ namespace OpenNest.Benchmark
                         salvageRate,
                         minimumSalvageDimension,
                         outputDirectory,
-                        progressLog,
+                        progressLog
-                        timeLimit,
-                        commonLines
                     )
             );
 
@@ -228,22 +214,13 @@ namespace OpenNest.Benchmark
             }
         }
 
-        /// <summary>The harness's own limit on a solve: five minutes, or a --time-limit plus a
-        /// grace period, so the engine's limit always fires first.</summary>
-        private static TimeSpan HarnessTimeout(TimeSpan? timeLimit) =>
-            timeLimit is { } limit && limit + TimeLimitGrace > SolveTimeout
-                ? limit + TimeLimitGrace
-                : SolveTimeout;
-
         private static JobResult RunOne(
             BenchmarkJob job,
             NestingEngineInfo engineInfo,
             double? salvageRate,
             double? minimumSalvageDimension,
             string outputDirectory,
-            System.IO.TextWriter progressLog,
+            System.IO.TextWriter progressLog
-            TimeSpan? timeLimit,
-            CommonLineSetting commonLines = null
         )
         {
             var requested = job.TotalRequestedQuantity;
@@ -257,22 +234,8 @@ namespace OpenNest.Benchmark
             {
                 var nestJob = job.BuildNestJob(MaxPlates, salvageRate, minimumSalvageDimension);
                 var engine = engineInfo.Factory();
-                if (timeLimit is { } limit)
+                using var cts = new CancellationTokenSource(SolveTimeout);
-                    engine = new DeadlineNestingEngine(engine, limit);
+                var jobResult = engine.Solve(nestJob, log, cts.Token);
-                using var cts = new CancellationTokenSource(HarnessTimeout(timeLimit));
-                NestJobResult jobResult;
-                if (commonLines != null)
-                {
-                    // Through the desktop's pipeline, so its common-line trial runs; every part
-                    // may pair. "off" is the like-for-like baseline for the levels.
-                    nestJob = commonLines.Apply(nestJob);
-                    var pipeline = NestPipeline.Run(engine, engineInfo.Name, nestJob,
-                        job.Requests.ToDictionary(r => r.Drawing.Id.ToString(), r => r.Drawing), log, cts.Token);
-                    nestJob = pipeline.Job;
-                    jobResult = pipeline.Raw;
-                }
-                else
-                    jobResult = engine.Solve(nestJob, log, cts.Token);
                 log?.Finished(jobResult, sw.ElapsedMilliseconds);
 
                 var materialized = NestResultMaterializer.Materialize(nestJob, jobResult);
@@ -393,7 +356,7 @@ namespace OpenNest.Benchmark
                     ElapsedMs = sw.ElapsedMilliseconds,
                 };
             }
-            catch (Exception ex) when (ex is OperationCanceledException || ex is TimeoutException)
+            catch (OperationCanceledException)
             {
                 sw.Stop();
                 log?.Failed("timed out", sw.ElapsedMilliseconds);
@@ -405,9 +368,7 @@ namespace OpenNest.Benchmark
                     PartsRequested = requested,
                     UnplacedPartPenalty = job.UnplacedPartPenalty,
                     ElapsedMs = sw.ElapsedMilliseconds,
-                    Error = ex is TimeoutException
+                    Error = $"Timed out after {SolveTimeout.TotalMinutes:F0} minute(s)",
-                        ? ex.Message
-                        : $"Timed out after {HarnessTimeout(timeLimit).TotalMinutes:0.#} minute(s)",
                 };
             }
             catch (Exception ex)

OpenNest.Benchmark/CommonLineSetting.cs

@@ -1,29 +0,0 @@
-using System.Linq;
-using OpenNest.CommonLines;
-using OpenNest.Engine.Jobs;
-
-namespace OpenNest.Benchmark
-{
-    /// <summary>
-    /// <c>--common-lines</c>: solve every job through <see cref="NestPipeline"/> at this usage
-    /// level and kerf, with every part allowed to share a common line.
-    /// </summary>
-    public sealed record CommonLineSetting(CommonLineUsage Usage, double Kerf)
-    {
-        public NestJob Apply(NestJob job)
-        {
-            var o = job.Options;
-            var options = new NestJobOptions(o.PlacementStrategy, o.MaxPlates, o.SalvageRate,
-                o.MinimumSalvageDimension, o.SearchUntilCancelled, o.OffcutCut)
-            {
-                CommonLineUsage = Usage,
-                CommonLineKerf = Kerf,
-            };
-            var parts = job.Parts.Select(p => new NestJobPart(p.Id, p.Geometry, p.Quantity, p.Priority, p.Rotation)
-            {
-                AllowCommonLine = true,
-            });
-            return new NestJob(parts, job.Plates, options);
-        }
-    }
-}

OpenNest.Benchmark/DxfManifestLoader.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text.Json;
-using OpenNest.CutOffs;
 using OpenNest.Geometry;
 using OpenNest.IO;
 
@@ -53,24 +52,9 @@ namespace OpenNest.Benchmark
                 PartSpacing = partSpacingOverride ?? manifest.Spacing,
                 Quadrant = manifest.Quadrant,
                 Requests = requests,
-                OffcutCut = OffcutCut(manifest.OffcutCut, manifestPath),
             };
         }
 
-        /// <summary>"horizontal" or "vertical" (any case); absent counts every edge strip.
-        /// </summary>
-        private static CutOffAxis? OffcutCut(string value, string manifestPath) =>
-            value?.ToLowerInvariant() switch
-            {
-                null => null,
-                "horizontal" => CutOffAxis.Horizontal,
-                "vertical" => CutOffAxis.Vertical,
-                _ => throw new InvalidOperationException(
-                    $"Manifest '{manifestPath}' has offcutCut \"{value}\"; "
-                        + "use \"horizontal\" or \"vertical\"."
-                ),
-            };
-
         private static Manifest ReadManifest(string manifestPath)
         {
             try
@@ -151,18 +135,12 @@ namespace OpenNest.Benchmark
                 throw new InvalidOperationException($"Failed to import DXF: {dxfPath}");
 
             // A zero legacy step means automatic rotation to DrawingJobMapper, so lock it explicitly.
-            // Quarter turns are a 90° sweep from 0 to 270°; automatic rotation allows any angle.
+            if (!part.AllowRotation)
-            var rotations = RotationSet(part);
-            if (rotations != RotationChoice.Any)
             {
-                var quarter = rotations == RotationChoice.QuarterTurns;
                 drawing.Constraints ??= new NestConstraints();
-                drawing.Constraints.StepAngle = quarter
+                drawing.Constraints.StepAngle = OpenNest.Math.Angle.TwoPI;
-                    ? OpenNest.Math.Angle.HalfPI
-                    : OpenNest.Math.Angle.TwoPI;
                 drawing.Constraints.StartAngle = 0;
-                drawing.Constraints.EndAngle = quarter ? 3 * OpenNest.Math.Angle.HalfPI : 0;
+                drawing.Constraints.EndAngle = 0;
-                drawing.Constraints.Allow180Equivalent = rotations == RotationChoice.HalfTurns;
             }
 
             var constraints = drawing.Constraints;
@@ -178,51 +156,12 @@ namespace OpenNest.Benchmark
             };
         }
 
-        private enum RotationChoice
-        {
-            None,
-            HalfTurns,
-            QuarterTurns,
-            Any,
-        }
-
-        /// <summary>
-        /// A part's "rotations" (degrees) must be {0}, {0, 180} or {0, 90, 180, 270}; without it,
-        /// "allowRotation" picks any angle (true, the default: automatic rotation) or none.
-        /// </summary>
-        private static RotationChoice RotationSet(ManifestPart part)
-        {
-            if (part.Rotations == null)
-                return part.AllowRotation ? RotationChoice.Any : RotationChoice.None;
-            if (!part.AllowRotation)
-                throw new InvalidOperationException(
-                    $"Manifest part '{part.Dxf}': set \"rotations\" or \"allowRotation\", not both."
-                );
-
-            var set = part.Rotations
-                .Select(degrees => ((degrees % 360) + 360) % 360)
-                .Distinct()
-                .OrderBy(degrees => degrees)
-                .ToArray();
-            if (set.SequenceEqual(new[] { 0.0 }))
-                return RotationChoice.None;
-            if (set.SequenceEqual(new[] { 0.0, 180.0 }))
-                return RotationChoice.HalfTurns;
-            if (set.SequenceEqual(new[] { 0.0, 90.0, 180.0, 270.0 }))
-                return RotationChoice.QuarterTurns;
-            throw new InvalidOperationException(
-                $"Manifest part '{part.Dxf}': \"rotations\" must be [0], [0, 180] or "
-                    + $"[0, 90, 180, 270] (was [{string.Join(", ", part.Rotations)}])."
-            );
-        }
-
         private class Manifest
         {
             public List<string> SheetSizes { get; set; }
             public double Spacing { get; set; }
             public double EdgeSpacing { get; set; }
             public int Quadrant { get; set; } = 1;
-            public string OffcutCut { get; set; }
             public List<ManifestPart> Parts { get; set; }
         }
 
@@ -231,7 +170,6 @@ namespace OpenNest.Benchmark
             public string Dxf { get; set; }
             public int Quantity { get; set; }
             public bool AllowRotation { get; set; } = true;
-            public List<double> Rotations { get; set; }
         }
     }
 }

OpenNest.Benchmark/JobLoader.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using OpenNest.Clamps;
 using OpenNest.Engine.BestFit;
 using OpenNest.Geometry;
 using OpenNest.IO;

OpenNest.Benchmark/Program.cs

@@ -4,7 +4,6 @@ using System.IO;
 using System.Linq;
 using OpenNest;
 using OpenNest.Benchmark;
-using OpenNest.CommonLines;
 using OpenNest.Engine.Jobs;
 using OpenNest.Geometry;
 
@@ -19,9 +18,6 @@ static class BenchmarkConsole
         if (options == null)
             return 0; // --help was requested
 
-        if (options.Invalid)
-            return 1;
-
         if (options.InputPath == null)
         {
             PrintUsage();
@@ -128,9 +124,7 @@ static class BenchmarkConsole
             options.MinimumSalvageDimension,
             options.OutputDirectory,
             options.Parallel,
-            options.Progress ? Console.Out : null,
+            options.Progress ? Console.Out : null
-            options.TimeLimit,
-            options.CommonLines
         );
 
         Report.PrintDetailed(results);
@@ -203,31 +197,10 @@ static class BenchmarkConsole
                         );
                     break;
 
-                case "--time-limit":
-                    o.TimeLimit = i + 1 < args.Length ? ParseTimeLimit(args[++i]) : null;
-                    if (o.TimeLimit == null)
-                    {
-                        Console.Error.WriteLine(
-                            "Error: --time-limit needs a number of seconds from 0.001 to "
-                                + $"{BenchmarkRunner.MaxTimeLimit.TotalSeconds:0}"
-                        );
-                        o.Invalid = true;
-                    }
-                    break;
-
                 case "--progress":
                     o.Progress = true;
                     break;
 
-                case "--common-lines" when i + 1 < args.Length:
-                    o.CommonLineLevel = args[++i];
-                    break;
-
-                case "--kerf" when i + 1 < args.Length:
-                    o.Kerf = double.TryParse(args[++i], System.Globalization.NumberStyles.Float,
-                        System.Globalization.CultureInfo.InvariantCulture, out var kerf) ? kerf : double.NaN;
-                    break;
-
                 case "--help":
                     PrintUsage();
                     return null;
@@ -239,25 +212,6 @@ static class BenchmarkConsole
             }
         }
 
-        if (o.CommonLineLevel != null)
-        {
-            CommonLineUsage? usage = o.CommonLineLevel.ToLowerInvariant() switch
-            {
-                "off" => CommonLineUsage.Off,
-                "when-it-adds-parts" => CommonLineUsage.WhenItAddsParts,
-                "whenever" => CommonLineUsage.Whenever,
-                _ => null,
-            };
-            if (usage == null || o.Kerf is not { } kerf || !double.IsFinite(kerf) || kerf <= 0)
-            {
-                Console.Error.WriteLine(
-                    "Error: --common-lines needs off, when-it-adds-parts or whenever, and a positive --kerf"
-                );
-                o.Invalid = true;
-            }
-            else
-                o.CommonLines = new CommonLineSetting(usage.Value, kerf);
-        }
         return o;
     }
 
@@ -281,22 +235,6 @@ static class BenchmarkConsole
         return sizes.Distinct().ToList();
     }
 
-    private static TimeSpan? ParseTimeLimit(string text)
-    {
-        if (
-            !double.TryParse(
-                text,
-                System.Globalization.NumberStyles.Float,
-                System.Globalization.CultureInfo.InvariantCulture,
-                out var seconds
-            )
-            || !(seconds >= 0.001)
-            || seconds > BenchmarkRunner.MaxTimeLimit.TotalSeconds
-        )
-            return null;
-        return TimeSpan.FromSeconds(seconds);
-    }
-
     private static void PrintUsage()
     {
         Console.Error.WriteLine(
@@ -392,24 +330,6 @@ static class BenchmarkConsole
         Console.Error.WriteLine(
             "  --progress                      Log each solve's start, engine progress and finish"
         );
-        Console.Error.WriteLine(
-            "  --time-limit <seconds>          Stop each solve at this wall-clock limit and score"
-        );
-        Console.Error.WriteLine(
-            "                                 the best valid plan reported; none = timed out"
-        );
-        Console.Error.WriteLine(
-            "  --common-lines <level>          Solve through the Auto Nest pipeline with every part allowed"
-        );
-        Console.Error.WriteLine(
-            "                                 to share a common line: off, when-it-adds-parts or whenever"
-        );
-        Console.Error.WriteLine(
-            "                                 (needs --kerf; off is the baseline to compare levels with)"
-        );
-        Console.Error.WriteLine(
-            "  --kerf <value>                  Common-line kerf in job units (with --common-lines)"
-        );
         Console.Error.WriteLine("  --help                          Show this message");
     }
 
@@ -425,10 +345,5 @@ static class BenchmarkConsole
         public double? MinimumSalvageDimension;
         public int Parallel = 3;
         public bool Progress;
-        public TimeSpan? TimeLimit;
-        public string CommonLineLevel;
-        public double? Kerf;
-        public CommonLineSetting CommonLines;
-        public bool Invalid;
     }
 }

OpenNest.Console/Program.cs

@@ -24,9 +24,6 @@ return NestConsole.Run(args);
 
 static class NestConsole
 {
-    private const string OutlinedSheetMessage =
-        "Error: Fill strategies need a rectangular sheet. Use --autonest --engine Irregular.";
-
     public static int Run(string[] args)
     {
         using var cancellation = new CancellationTokenSource();
@@ -38,7 +35,7 @@ static class NestConsole
         }
         catch (OperationCanceledException)
         {
-            Console.Error.WriteLine("Nesting canceled; nothing saved.");
+            Console.Error.WriteLine("Nesting cancelled; nothing saved.");
             return 2;
         }
         catch (Exception ex)
@@ -135,26 +132,14 @@ static class NestConsole
 
         if (options.NoFill && (options.AutoNest || options.KeepParts || options.DrawingName != null
             || options.Quantity != 0 || options.Spacing.HasValue || options.PlateSize.HasValue
-            || options.OutlineFile != null || options.TemplateFile != null || options.InputFiles.Any(IsCadFile)))
+            || options.TemplateFile != null || options.InputFiles.Any(IsCadFile)))
         {
             Console.Error.WriteLine(
-                "Error: --no-fill keeps the nest as loaded; it cannot be combined with CAD inputs, --autonest, --keep-parts, --drawing, --quantity, --spacing, --size, --outline or --template."
+                "Error: --no-fill keeps the nest as loaded; it cannot be combined with CAD inputs, --autonest, --keep-parts, --drawing, --quantity, --spacing, --size or --template."
             );
             return 1;
         }
 
-        if (options.OutlineFile != null && !options.AutoNest)
-        {
-            Console.Error.WriteLine("Error: --outline needs --autonest; single-plate fill strategies fill rectangles only.");
-            return 1;
-        }
-
-        if (options.OutlineFile != null && !File.Exists(options.OutlineFile))
-        {
-            Console.Error.WriteLine($"Error: Outline file not found: {options.OutlineFile}");
-            return 1;
-        }
-
         if (options.InputFiles.Count == 0)
         {
             PrintUsage();
@@ -212,12 +197,6 @@ static class NestConsole
             ApplyTemplate(plate, options);
             ApplyOverrides(plate, options);
 
-            if (!options.AutoNest && PlateFillService.Refusal(plate) != null)
-            {
-                Console.Error.WriteLine(OutlinedSheetMessage);
-                return 2;
-            }
-
             var drawing = ResolveDrawing(nest, options);
 
             if (drawing == null)
@@ -278,9 +257,6 @@ static class NestConsole
                         _ => BendRepairUnits.Unspecified,
                     };
                     break;
-                case "--svg-units-per-inch" when i + 1 < args.Length:
-                    o.SvgUnitsPerInch = double.Parse(args[++i], CultureInfo.InvariantCulture);
-                    break;
                 case "--drawing" when i + 1 < args.Length:
                     o.DrawingName = args[++i];
                     break;
@@ -300,9 +276,6 @@ static class NestConsole
                     if (Size.TryParse(args[++i], out var sz))
                         o.PlateSize = sz;
                     break;
-                case "--outline" when i + 1 < args.Length:
-                    o.OutlineFile = args[++i];
-                    break;
                 case "--check-overlaps":
                     o.CheckOverlaps = true;
                     break;
@@ -411,10 +384,9 @@ static class NestConsole
         return stock;
     }
 
-    static bool IsCadFile(string path) => CadFormats.IsCadFile(path);
+    static bool IsCadFile(string path) =>
-
+        path.EndsWith(".dxf", StringComparison.OrdinalIgnoreCase)
-    static Units DrawingUnits(Options options) =>
+        || path.EndsWith(".dwg", StringComparison.OrdinalIgnoreCase);
-        options.CadUnits == BendRepairUnits.Millimeters ? Units.Millimeters : Units.Inches;
 
     static Nest LoadOrCreateNest(Options options)
     {
@@ -460,7 +432,7 @@ static class NestConsole
         // DXF-only mode: create a fresh nest.
         if (dxfFiles.Count == 0)
         {
-            Console.Error.WriteLine("Error: no nest (.nest) or CAD (.dxf/.dwg/.svg) files specified");
+            Console.Error.WriteLine("Error: no nest (.nest) or CAD (.dxf/.dwg) files specified");
             return null;
         }
 
@@ -507,12 +479,8 @@ static class NestConsole
                             MaxEndpointMovementMillimeters = options.RepairBendsMillimeters.Value,
                         }
                         : null,
-                    DrawingUnits = DrawingUnits(options),
-                    SvgUserUnitsPerInch = options.SvgUnitsPerInch,
                 }
             );
-            foreach (var warning in result.Warnings)
-                Console.Error.WriteLine($"Warning: {Path.GetFileName(path)}: {warning}");
             foreach (var report in result.BendRepairReports)
                 Console.WriteLine(
                     $"Bend repair {Path.GetFileName(path)} #{report.BendIndex + 1}: {report.Status}: {report.Reason} ({report.OriginalStart} -> {report.Start}; {report.OriginalEnd} -> {report.End})"
@@ -558,22 +526,6 @@ static class NestConsole
 
         if (options.PlateSize.HasValue && !hasDxfOnly)
             plate.Size = options.PlateSize.Value;
-
-        if (options.OutlineFile != null)
-        {
-            // The outline is the sheet: its bounds replace any size given.
-            plate.Outline = SheetOutline.FromGeometry(
-                CadImporter.Import(
-                    options.OutlineFile,
-                    new CadImportOptions
-                    {
-                        DrawingUnits = DrawingUnits(options),
-                        SvgUserUnitsPerInch = options.SvgUnitsPerInch,
-                    }
-                ).Entities
-            );
-            Console.WriteLine($"Outline: {options.OutlineFile} ({plate.Outline})");
-        }
     }
 
     static Drawing ResolveDrawing(Nest nest, Options options)
@@ -637,13 +589,17 @@ static class NestConsole
 
         if (options.AutoNest)
         {
-            var nestItems = AutoNestItems(nest, plate, drawing, options);
+            var nestItems = new List<NestItem>();
-            if (nestItems.Count == 0)
+            var qty = options.Quantity > 0 ? options.Quantity : 1;
+
+            if (options.DrawingName != null)
             {
-                Console.Error.WriteLine(
+                nestItems.Add(new NestItem { Drawing = drawing, Quantity = qty });
-                    "Error: other plates already hold every required part. Use --quantity to nest more. Nothing saved."
+            }
-                );
+            else
-                return (false, sw.ElapsedMilliseconds, false, plates);
+            {
+                foreach (var d in nest.Drawings)
+                    nestItems.Add(new NestItem { Drawing = d, Quantity = qty });
             }
 
             Console.WriteLine(
@@ -681,38 +637,6 @@ static class NestConsole
         return (success, sw.ElapsedMilliseconds, accepted, plates);
     }
 
-    /// <summary>
-    /// The job's demand: --quantity of each drawing when given, otherwise each drawing's
-    /// required quantity less the copies on other plates (the target's parts are replaced).
-    /// As in Desktop Auto Nest, a drawing without a required quantity is left out, unless no
-    /// drawing has one: then one of each is nested.
-    /// </summary>
-    static List<NestItem> AutoNestItems(Nest nest, Plate target, Drawing drawing, Options options)
-    {
-        var drawings = (options.DrawingName != null ? new[] { drawing } : nest.Drawings.ToArray())
-            .Where(d => !d.IsCutOff)
-            .ToList();
-        var anyRequired = drawings.Any(d => d.Quantity.Required > 0);
-
-        int Demand(Drawing d)
-        {
-            if (options.Quantity > 0)
-                return options.Quantity;
-            if (!anyRequired)
-                return 1;
-
-            var elsewhere = nest.Plates
-                .Where(p => p != target)
-                .Sum(p => p.Parts.Count(part => part.BaseDrawing == d) * p.Quantity);
-            return d.Quantity.Required - elsewhere;
-        }
-
-        return drawings
-            .Select(d => new NestItem { Drawing = d, Quantity = Demand(d) })
-            .Where(item => item.Quantity > 0)
-            .ToList();
-    }
-
     static (bool accepted, int committed, IReadOnlyList<Plate> plates) AutoNestJob(
         Nest nest, Plate plate, List<NestItem> nestItems, Options options, CancellationToken token)
     {
@@ -789,14 +713,14 @@ static class NestConsole
         var total = 0;
         foreach (var plate in plates.Where(p => p.Parts.Count > 0))
         {
-            var overlapping = PartOverlapChecker.FindOverlappingPairs(plate.Parts);
+            var hasOverlaps = plate.HasOverlappingParts(out var overlapPts);
             var label = plates.Count > 1 ? $"Plate {nest.Plates.IndexOf(plate)}: " : "";
             Console.WriteLine(
-                overlapping.Count > 0
+                hasOverlaps
-                    ? $"{label}OVERLAPS DETECTED: {overlapping.Count} overlapping pair(s)"
+                    ? $"{label}OVERLAPS DETECTED: {overlapPts.Count} intersection points"
                     : $"{label}Overlap check: PASS"
             );
-            total += overlapping.Count;
+            total += overlapPts.Count;
         }
 
         return total;
@@ -1013,17 +937,6 @@ static class NestConsole
             return false;
         }
 
-        // A common line cut once needs a post that writes it; none falls back to cutting it twice.
-        try
-        {
-            OpenNest.CNC.CommonLineCuts.EnsurePostable(nest, post);
-        }
-        catch (InvalidOperationException ex)
-        {
-            Console.Error.WriteLine($"Error: {ex.Message} No output was written.");
-            return false;
-        }
-
         var verification = PostVerificationAnalyzer.AnalyzeForPost(nest, post);
         Console.WriteLine(verification.ToDisplayText());
         if (!verification.CanPost(options.AcknowledgePostRisks))
@@ -1068,7 +981,7 @@ static class NestConsole
             Usage: OpenNest.Console <input-files...> [options]
 
             Arguments:
-              input-files            One or more .nest nest files or .dxf/.dwg/.svg drawing files
+              input-files            One or more .nest nest files or .dxf/.dwg drawing files
 
             Modes:
               <nest.nest>             Load nest and fill (existing behavior)
@@ -1077,19 +990,12 @@ static class NestConsole
 
             Options:
               --repair-bends-mm <n>   Opt-in endpoint/tick repair, limit >0.001 to 3.175 physical mm
-              --cad-units inches|mm  Explicit source coordinate units required for bend repair;
+              --cad-units inches|mm  Explicit source coordinate units required for bend repair
-                                     also the units SVGs import in (default inches)
-              --svg-units-per-inch N SVG units per inch, for a file without a real-world size
               --drawing <name>       Drawing name to fill with (default: first drawing)
               --plate <index>        Plate index to fill (default: 0)
-              --quantity <n>          Max parts to place (default: 0 = unlimited). With --autonest: copies of
+              --quantity <n>          Max parts to place (default: 0 = unlimited)
-                                     each drawing (default: its required quantity less copies on other
-                                     plates; one of each when no drawing has a required quantity)
               --spacing <value>      Override part spacing
               --size <WxL>           Override plate size (e.g. 60x120); required for DXF-only mode
-              --outline <dxf>        Make the plate an irregular sheet: the file's largest closed contour is
-                                     the sheet, other closed contours are obstacles; sets the size. Only
-                                     --autonest with the Irregular (or Default) engine nests on it
               --output <path>        Output nest file path (default: <input>-result.nest)
               --template <path>      Nest template for plate defaults (thickness, quadrant, material, spacing)
               --autonest             Validated whole-job nesting (one sheet unless --max-sheets); replaces only after acceptance
@@ -1098,10 +1004,8 @@ static class NestConsole
               --stock <WxL[:cost],...>  With --autonest: sheet sizes to offer, each unlimited (default: the
                                      target plate's size); spacing, quadrant and clamps follow the target
               --allow-invalid        Explicitly keep representable invalid autonest layouts (default: reject, exit 2)
-              --engine <name>        With --autonest: jobs engine (default: Default; also Irregular,
+              --engine <name>        With --autonest: jobs engine (default: Default; also Irregular, Rectangles, Fill, ...).
-                                     Rectangles, Lattice, ...). Without --autonest: fill strategy
+                                     Without --autonest: fill strategy (Fill (default), Strip, Vertical Remnant, Horizontal Remnant)
-                                     (Lattice (default), Strip, Vertical Remnant,
-                                     Horizontal Remnant)
               --keep-parts           Don't clear existing parts before filling
               --no-fill              Keep the loaded .nest as it is (no fill); plan, save or post it
               --plan-cutting         After filling (or loading with --no-fill), plan cutting (part order,
@@ -1133,7 +1037,6 @@ static class NestConsole
         public int Quantity;
         public double? Spacing;
         public Size? PlateSize;
-        public string OutlineFile;
         public bool CheckOverlaps;
         public bool NoSave;
         public bool KeepParts;
@@ -1156,6 +1059,5 @@ static class NestConsole
         public bool AllPlates;
         public double? RepairBendsMillimeters;
         public BendRepairUnits CadUnits;
-        public double? SvgUnitsPerInch;
     }
 }

OpenNest.Core/AppliedCuttingWork.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using OpenNest.CutOffs;
 
 namespace OpenNest;
 

OpenNest.Core/AutomaticCutOffBatch.cs

@@ -2,7 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace OpenNest.CutOffs;
+namespace OpenNest;
 
 /// <summary>
 /// Plans and applies the same automatic-cutoff settings to a stable, ordered set of plates.

OpenNest.Core/AutomaticCutOffPlanner.cs

@@ -1,13 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using OpenNest.Clamps;
 using OpenNest.CNC;
 using OpenNest.Converters;
 using OpenNest.Geometry;
 using OpenNest.Math;
 
-namespace OpenNest.CutOffs;
+namespace OpenNest;
 
 public sealed class AutomaticCutOffOptions
 {
@@ -50,7 +49,6 @@ public enum AutomaticCutOffDiagnosticCode
     ShiftedCut,
     HorizontalRemnant,
     NoSafeHorizontalSeparator,
-    ClampMovedTailSeparator,
 }
 
 public sealed record AutomaticCutOffDiagnostic(
@@ -169,21 +167,7 @@ public static class AutomaticCutOffPlanner
         occupied = System.Math.Min(occupied, length);
         occupiedY = System.Math.Min(occupiedY, width);
         var margin = System.Math.Max(plate.PartSpacing, settings.PartClearance) + GeometryTolerance;
-        var nominalSeparator = occupied + margin;
+        var separator = occupied + margin;
-        // A separator on a clamp moves just past it, away from the origin: the tail is a
-        // little shorter, but a clamp in the way no longer costs the whole remnant. Repeat
-        // for a clamp whose clearance the moved line now meets.
-        var separator = nominalSeparator;
-        ClampZone movedPast = null;
-        for (var pass = 0; pass <= clamps.Count && double.IsFinite(separator); pass++)
-        {
-            var blocking = clamps.FirstOrDefault(zone => CrossesClamp(zone, sign * separator));
-            if (blocking == null)
-                break;
-            movedPast = blocking;
-            var farEdge = sign > 0 ? blocking.Bounds.Right : -blocking.Bounds.Left;
-            separator = farEdge + plate.ClampClearance + GeometryTolerance;
-        }
         var hasTailCandidate = double.IsFinite(separator) && separator < length - GeometryTolerance;
         var diagnostics = new List<AutomaticCutOffDiagnostic>();
 
@@ -212,7 +196,7 @@ public static class AutomaticCutOffPlanner
             var y = ySign * horizontalDistance.Value;
             var limited = plate.CutOffs.Any(c => c?.Axis == CutOffAxis.Horizontal && Near(c.Position.Y, y));
             var clamp = clamps.FirstOrDefault(zone =>
-                y >= zone.Bounds.Bottom - plate.ClampClearance && y <= zone.Bounds.Top + plate.ClampClearance);
+                y >= zone.Bounds.Bottom - plate.EdgeSpacing.Bottom && y <= zone.Bounds.Top + plate.EdgeSpacing.Bottom);
             if (limited || clamp != null)
             {
                 diagnostics.Add(new AutomaticCutOffDiagnostic(
@@ -322,14 +306,7 @@ public static class AutomaticCutOffPlanner
             }
         }
         if (keepsTail)
-        {
-            if (movedPast != null)
-                diagnostics.Add(new AutomaticCutOffDiagnostic(
-                    AutomaticCutOffDiagnosticCode.ClampMovedTailSeparator,
-                    $"The tail separator moved from {sign * nominalSeparator:G8} to {sign * separator:G8} "
-                    + $"to clear clamp '{movedPast.Id}' (including its clearance).", X: sign * separator));
             AddCandidate(sign * separator, true);
-        }
         else if (hasTailCandidate)
             diagnostics.Add(new AutomaticCutOffDiagnostic(
                 AutomaticCutOffDiagnosticCode.TailBelowMinimum,
@@ -394,7 +371,7 @@ public static class AutomaticCutOffPlanner
 
         // A full-span line, or one with the limits this plan gives its own vertical lines.
         bool Spans(CutOff cut) => FullSpanLimits(cut, bounds, settings) ||
-            horizontalY.HasValue && cut.Gaps.Count == 0 &&
+            horizontalY.HasValue &&
             Near(cut.StartLimit ?? bounds.Bottom, startLimit ?? bounds.Bottom) &&
             Near(cut.EndLimit ?? (bounds.Top + settings.Overtravel), endLimit ?? (bounds.Top + settings.Overtravel));
 
@@ -483,7 +460,7 @@ public static class AutomaticCutOffPlanner
             {
                 diagnostics.Add(new AutomaticCutOffDiagnostic(
                     AutomaticCutOffDiagnosticCode.ClampBlockedCut,
-                    $"The proposed cut crosses clamp '{blocked.Id}' (including its clearance); it was skipped.",
+                    $"The proposed cut crosses clamp '{blocked.Id}' (including bottom-edge clearance); it was skipped.",
                     X: x));
                 if (isSeparator)
                     WarnNoSeparator(x);
@@ -496,7 +473,7 @@ public static class AutomaticCutOffPlanner
             var candidate = existing == null
                 ? NewVertical(x)
                 : new CutOff(existing.Position, existing.Axis)
-                { StartLimit = existing.StartLimit, EndLimit = existing.EndLimit, Gaps = existing.Gaps };
+                { StartLimit = existing.StartLimit, EndLimit = existing.EndLimit };
             candidate.Regenerate(plate, settings, cache);
             var program = candidate.Drawing.Program;
             var usable = HasUsableSegments(program);
@@ -545,7 +522,7 @@ public static class AutomaticCutOffPlanner
         // Share the exact placement-frame predicate with candidate exclusion and final
         // certification. Infeasible gaps still use nominal lines through AddCandidate.
         bool CrossesClamp(ClampZone zone, double x) =>
-            x >= zone.Bounds.Left - plate.ClampClearance && x <= zone.Bounds.Right + plate.ClampClearance;
+            x >= zone.Bounds.Left - plate.EdgeSpacing.Bottom && x <= zone.Bounds.Right + plate.EdgeSpacing.Bottom;
 
         void WarnNoSeparator(double x) => diagnostics.Add(new AutomaticCutOffDiagnostic(
             AutomaticCutOffDiagnosticCode.NoSafeTailSeparator,
@@ -567,12 +544,10 @@ public static class AutomaticCutOffPlanner
             double.IsFinite(plate.Size.Width) && plate.Size.Width > 0,
             "Sheet length and width must be positive and finite.", nameof(plate));
         Require(plate.Quadrant is >= 1 and <= 4, "Quadrant must be 1 through 4.", nameof(plate));
-        // Strips are planned across a rectangle's known span; an outlined sheet gets manual cut-offs only.
-        Require(plate.Outline == null, "Automatic cut-offs need a rectangular sheet; this plate has an outline.", nameof(plate));
         Require(Nonnegative(plate.PartSpacing), "Part spacing must be finite and nonnegative.", nameof(plate));
         Require(plate.ClampZones != null && (plate.ClampZones.Count == 0 ||
-            Nonnegative(plate.ClampClearance)),
+            Nonnegative(plate.EdgeSpacing.Bottom)),
-            "Clamp zones and clamp clearance must be finite and valid.", nameof(plate));
+            "Clamp zones and bottom-edge clearance must be finite and valid.", nameof(plate));
         Require(Nonnegative(settings.PartClearance) && Nonnegative(settings.MinSegmentLength) &&
             Nonnegative(settings.Overtravel), "Cut-off settings must be finite and nonnegative.", nameof(settings));
         Require(!settings.LockHeadHeight || double.IsFinite(settings.HeadLockOvercut) && settings.HeadLockOvercut > 0,
@@ -677,9 +652,7 @@ public static class AutomaticCutOffPlanner
         }
     }
 
-    // A gapped line never runs full span, whatever its limits.
     private static bool FullSpanLimits(CutOff cut, Box bounds, CutOffSettings settings) =>
-        cut.Gaps.Count == 0 &&
         Near(cut.StartLimit ?? bounds.Bottom, bounds.Bottom) &&
         Near(cut.EndLimit ?? (bounds.Top + settings.Overtravel), bounds.Top + settings.Overtravel);
 
@@ -700,7 +673,6 @@ public static class AutomaticCutOffPlanner
     }
 
     private static bool FullLengthLimits(CutOff cut, Box bounds, CutOffSettings settings) =>
-        cut.Gaps.Count == 0 &&
         Near(cut.StartLimit ?? bounds.Left, bounds.Left) &&
         Near(cut.EndLimit ?? (bounds.Right + settings.Overtravel), bounds.Right + settings.Overtravel);
 

OpenNest.Core/AutomaticCutOffStripSearch.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Numerics;
 
-namespace OpenNest.CutOffs;
+namespace OpenNest;
 
 /// <summary>Exact layered search over sorted positions; each transition uses a sliding minimum.</summary>
 internal static class AutomaticCutOffStripSearch

OpenNest.Core/Bending/Bend.cs

@@ -62,8 +62,8 @@ namespace OpenNest.Bending
             else
             {
                 var angle = StartPoint.AngleTo(EndPoint);
-                var dx = PortableMath.Cos(angle) * etchLength;
+                var dx = System.Math.Cos(angle) * etchLength;
-                var dy = PortableMath.Sin(angle) * etchLength;
+                var dy = System.Math.Sin(angle) * etchLength;
 
                 result.Add(
                     CreateEtchLine(StartPoint, new Vector(StartPoint.X + dx, StartPoint.Y + dy))

OpenNest.Core/Breakoffs/BreakoffBuilder.cs

@@ -8,7 +8,7 @@ namespace OpenNest.Breakoffs
 {
     /// <summary>
     /// Resolves and applies <see cref="Breakoff"/>s: the joining line becomes open cuts on the
-    /// break layer between tabs, each traveling with the scrap on its left so the cutting
+    /// break layer between tabs, each travelling with the scrap on its left so the cutting
     /// strategies pierce and lead in from the scrap.
     /// </summary>
     public static class BreakoffBuilder

OpenNest.Core/Breakoffs/BreakoffLayout.cs

@@ -49,7 +49,7 @@ namespace OpenNest.Breakoffs
 
         /// <summary>
         /// <paramref name="center"/> for tab <paramref name="index"/> limited so the tab stays on the
-        /// joining line and keeps a gap from its neighbors.
+        /// joining line and keeps a gap from its neighbours.
         /// </summary>
         public double ClampTabCenter(int index, double center)
         {

OpenNest.Core/Breakoffs/BreakoffPath.cs

@@ -153,8 +153,8 @@ namespace OpenNest.Breakoffs
             }
             var arc = (Arc)e;
             var angle = ArcAngleAt(arc, local);
-            return new Vector(arc.Center.X + arc.Radius * PortableMath.Cos(angle),
+            return new Vector(arc.Center.X + arc.Radius * System.Math.Cos(angle),
-                arc.Center.Y + arc.Radius * PortableMath.Sin(angle));
+                arc.Center.Y + arc.Radius * System.Math.Sin(angle));
         }
 
         private static Vector TangentOn(Entity e, double local)
@@ -168,8 +168,8 @@ namespace OpenNest.Breakoffs
             var arc = (Arc)e;
             var angle = ArcAngleAt(arc, local);
             return arc.IsReversed
-                ? new Vector(PortableMath.Sin(angle), -PortableMath.Cos(angle))
+                ? new Vector(System.Math.Sin(angle), -System.Math.Cos(angle))
-                : new Vector(-PortableMath.Sin(angle), PortableMath.Cos(angle));
+                : new Vector(-System.Math.Sin(angle), System.Math.Cos(angle));
         }
 
         private static double ArcAngleAt(Arc arc, double local) =>

OpenNest.Core/CNC/CommonLineCuts.cs

@@ -1,74 +0,0 @@
-using System;
-using System.Linq;
-
-namespace OpenNest.CNC
-{
-    /// <summary>
-    /// How a planned program cuts a common line once (see docs/common-line-cutting.md). A shared cut
-    /// is a run of <see cref="LayerType.CommonLine"/> moves: an open centerline cut made without
-    /// kerf compensation, with straight leads on its own axis. A remainder (a member's perimeter
-    /// between its shared spans) is an open contour whose rapid is followed directly by one of the
-    /// <see cref="RemainderMarker(RotationType)"/> comments, naming the winding of the perimeter it
-    /// belongs to, so a post compensates it on the perimeter's side even though it encloses nothing.
-    /// </summary>
-    public static class CommonLineCuts
-    {
-        /// <summary>The comment after the rapid into a remainder of a clockwise perimeter.</summary>
-        public const string ClockwiseRemainder = "COMMON LINE REMAINDER CW";
-
-        /// <summary>The comment after the rapid into a remainder of a counterclockwise perimeter.</summary>
-        public const string CounterclockwiseRemainder = "COMMON LINE REMAINDER CCW";
-
-        /// <summary>The remainder comment for a perimeter wound <paramref name="winding"/>.</summary>
-        public static string RemainderMarker(RotationType winding) =>
-            winding == RotationType.CW ? ClockwiseRemainder : CounterclockwiseRemainder;
-
-        /// <summary>The perimeter winding a remainder comment names, or null for any other code.</summary>
-        public static RotationType? RemainderWinding(ICode code) => code switch
-        {
-            Comment { Value: ClockwiseRemainder } => RotationType.CW,
-            Comment { Value: CounterclockwiseRemainder } => RotationType.CCW,
-            _ => null,
-        };
-
-        /// <summary>Whether <paramref name="program"/>'s own codes cut a common line once.</summary>
-        public static bool IsSinglePass(Program program) =>
-            program?.Codes != null && program.Codes.Any(code =>
-                code is LinearMove { Layer: LayerType.CommonLine } or ArcMove { Layer: LayerType.CommonLine }
-                || RemainderWinding(code) != null);
-
-        /// <summary>
-        /// Refuses, before any output, a nest with a common line cut once when
-        /// <paramref name="postProcessor"/> cannot write shared cuts and remainders: it would cut the
-        /// shared cut with compensation (into a part) or a remainder on the wrong side. Posts never
-        /// fall back to cutting the line twice; set the plate to cut its common lines twice instead.
-        /// </summary>
-        /// <exception cref="InvalidOperationException">The post cannot write the nest.</exception>
-        public static void EnsurePostable(Nest nest, IPostProcessor postProcessor)
-        {
-            ArgumentNullException.ThrowIfNull(nest);
-            if (postProcessor is ICommonLinePostProcessor)
-                return;
-            for (var p = 0; p < nest.Plates.Count; p++)
-            {
-                var plate = nest.Plates[p];
-                for (var i = 0; i < plate.Parts.Count; i++)
-                    if (IsSinglePass(plate.Parts[i]?.Program))
-                        throw new InvalidOperationException(
-                            $"Plate {p + 1}, part {i + 1} cuts a common line once, but the "
-                            + $"{postProcessor?.Name ?? "selected"} post cannot write single-pass common lines. "
-                            + "Set the plate to cut its common lines twice (Plate > Arrange > Cut Common Lines Twice), "
-                            + "plan cutting again, then post.");
-            }
-        }
-    }
-
-    /// <summary>
-    /// A post that writes common lines cut once (<see cref="CommonLineCuts"/>): each shared cut
-    /// without kerf compensation and each remainder compensated on its perimeter's side. Posts
-    /// without it refuse such a nest (<see cref="CommonLineCuts.EnsurePostable"/>).
-    /// </summary>
-    public interface ICommonLinePostProcessor : IPostProcessor
-    {
-    }
-}

OpenNest.Core/CNC/CutSimulation.cs

@@ -123,7 +123,7 @@ namespace OpenNest.CNC
             {
                 var angle = StartAngle + Sweep * fraction;
                 var sign = System.Math.Sign(Sweep);
-                return new Vector(-PortableMath.Sin(angle) * sign, PortableMath.Cos(angle) * sign);
+                return new Vector(-System.Math.Sin(angle) * sign, System.Math.Cos(angle) * sign);
             }
             return Length > 0 ? new Vector((End.X - Start.X) / Length, (End.Y - Start.Y) / Length) : Vector.Zero;
         }
@@ -137,8 +137,8 @@ namespace OpenNest.CNC
             {
                 var angle = StartAngle + Sweep * fraction;
                 return new Vector(
-                    Center.X + Radius * PortableMath.Cos(angle),
+                    Center.X + Radius * System.Math.Cos(angle),
-                    Center.Y + Radius * PortableMath.Sin(angle));
+                    Center.Y + Radius * System.Math.Sin(angle));
             }
 
             return new Vector(
@@ -379,7 +379,7 @@ namespace OpenNest.CNC
                 {
                     // Cutting strategies emit contour moves on Display; the posts cut them.
                     LayerType.Cut or LayerType.Display or LayerType.Leadin or LayerType.Leadout or LayerType.Break
-                        or LayerType.CommonLine => CutSimulationStepKind.Cut,
+                        => CutSimulationStepKind.Cut,
                     LayerType.Scribe => CutSimulationStepKind.Scribe,
                     _ => null, // Tab spans are never cut.
                 };

OpenNest.Core/CNC/CuttingPlanning/ContourEntryCandidate.cs

@@ -53,7 +53,7 @@ internal enum AutomaticEntryKind
 
 /// <summary>
 /// Which automatic entries a perimeter tabbed for support offers (see
-/// <see cref="PreparedContours.WithSupportTab"/>); every other contour offers its whole catalog.
+/// <see cref="PreparedContours.WithSupportTab"/>); every other contour offers its whole catalogue.
 /// </summary>
 internal enum SupportEntries
 {
@@ -70,11 +70,9 @@ internal enum SupportEntries
 /// <summary>
 /// One automatic start candidate: the owned contour choice plus its preference kind and a
 /// stable geometry tie key for deterministic ranking. The choice keeps this preparation as
-/// owner; nothing here exposes or mutates the underlying shape. <paramref name="CornerReach"/>
+/// owner; nothing here exposes or mutates the underlying shape.
-/// is how far a corner fillet's joint lies from the sharp corner it rounds (0 otherwise), so
-/// ranking can count it on both of that corner's sides.
 /// </summary>
-internal sealed record ContourEntryCandidate(ContourChoice Choice, AutomaticEntryKind Kind, double CornerReach = 0)
+internal sealed record ContourEntryCandidate(ContourChoice Choice, AutomaticEntryKind Kind)
 {
     /// <summary>
     /// Stable geometric tie key: the point quantized to the preparation epsilon grid, so

OpenNest.Core/CNC/CuttingPlanning/ContourEntryRanking.cs

@@ -7,7 +7,7 @@ using OpenNest.Geometry;
 namespace OpenNest.CNC.CuttingPlanning;
 
 /// <summary>
-/// Pure deterministic ordering of the automatic entry catalog toward the next cut:
+/// Pure deterministic ordering of the automatic entry catalogue toward the next cut:
 /// circles rank by outgoing distance; other contours use facing sides, tier and travel,
 /// then a stable geometric key. It adds no
 /// candidates, mutates nothing, runs no lead checks and applies no cap — feasibility
@@ -62,12 +62,12 @@ internal static class ContourEntryRanking
             if (p.Y > maxY) maxY = p.Y;
         }
 
-        // Facing sides from the target relative to the center, matching the source plan:
+        // Facing sides from the target relative to the centre, matching the source plan:
-        // horizontal right when the target is right of center else left; vertical likewise.
+        // horizontal right when the target is right of centre else left; vertical likewise.
-        var centerX = minX + (maxX - minX) * 0.5;
+        var centreX = minX + (maxX - minX) * 0.5;
-        var centerY = minY + (maxY - minY) * 0.5;
+        var centreY = minY + (maxY - minY) * 0.5;
-        var facingRight = target != null && target.Value.X > centerX;
+        var facingRight = target != null && target.Value.X > centreX;
-        var facingTop = target != null && target.Value.Y > centerY;
+        var facingTop = target != null && target.Value.Y > centreY;
 
         return candidates
             .Select(c => (Candidate: c, Score: Score(c, minX, minY, maxX, maxY, facingRight, facingTop, target, arrival)))
@@ -107,18 +107,16 @@ internal static class ContourEntryRanking
         if (target != null)
         {
             // Nearest side(s) of the candidate bounding rectangle (a corner belongs to two
-            // sides within tolerance, a fillet's joint within its reach of the corner it
+            // sides within tolerance); count how many of them are facing sides.
-            // rounds); count how many of them are facing sides.
             var left = p.X - minX;
             var right = maxX - p.X;
             var bottom = p.Y - minY;
             var top = maxY - p.Y;
             var min = System.Math.Min(System.Math.Min(left, right), System.Math.Min(bottom, top));
-            var near = min + PostVerificationGeometry.Epsilon + candidate.CornerReach;
+            if (facingRight && right <= min + PostVerificationGeometry.Epsilon) facing++;
-            if (facingRight && right <= near) facing++;
+            if (!facingRight && left <= min + PostVerificationGeometry.Epsilon) facing++;
-            if (!facingRight && left <= near) facing++;
+            if (facingTop && top <= min + PostVerificationGeometry.Epsilon) facing++;
-            if (facingTop && top <= near) facing++;
+            if (!facingTop && bottom <= min + PostVerificationGeometry.Epsilon) facing++;
-            if (!facingTop && bottom <= near) facing++;
         }
         var travel = (arrival != null ? arrival.Value.DistanceTo(p) : 0.0)
             + (target != null ? p.DistanceTo(target.Value) : 0.0);

OpenNest.Core/CNC/CuttingPlanning/ContourProgramVerifier.cs

@@ -47,8 +47,7 @@ internal static class ContourProgramVerifier
         if (material == null || !material.IsComplete) return false;
         if (selected != null && !SameEmission(actual, selected.Expected, token, ref budget)) return false;
         var visited = new HashSet<int>();
-        // Per tabbed ring: what each run cut, as (span start, from, to) along its span.
+        var piecesCut = new Dictionary<int, HashSet<int>>();
-        var piecesCut = new Dictionary<int, List<(int Span, double From, double To)>>();
         foreach (var run in Runs(actual).Where(r => !r.Rapid && r.Kind == LayerType.Cut))
         {
             token.ThrowIfCancellationRequested();
@@ -77,13 +76,12 @@ internal static class ContourProgramVerifier
             var tabs = material.Tabs[ringIndex];
             if (tabs.Any(tab => tab))
             {
-                // A tabbed ring: each run follows one span between tabs and never crosses a tab. A
+                // A tabbed cutout: each run cuts exactly one span between tabs, whole and once.
-                // span is usually one run; a common-line member that starts on its common line cuts
+                if (!CutsTabbedSpan(run.Curves, material.Rings[ringIndex], tabs, entityIndex, token, ref budget)
-                // the span holding that start in two, each from where the other began or ended.
+                    || !(piecesCut.TryGetValue(ringIndex, out var cut) ? cut : piecesCut[ringIndex] = new()).Add(entityIndex))
-                if (CutTabbedSpan(run.Curves, material.Rings[ringIndex], tabs, entityIndex, token, ref budget)
-                    is not { } piece)
                     return false;
-                (piecesCut.TryGetValue(ringIndex, out var cut) ? cut : piecesCut[ringIndex] = new()).Add(piece);
+                if (piecesCut[ringIndex].Count == SpanStarts(tabs).Count)
+                    visited.Add(ringIndex);
                 continue;
             }
             if (!visited.Add(ringIndex)) return false;
@@ -111,27 +109,6 @@ internal static class ContourProgramVerifier
             if (!Follows(run.Curves, ring, entityIndex, ring[entityIndex].DistanceAlong(first.Start),
                 true, tolerance, token, ref budget)) return false;
         }
-        // Every span of a tabbed ring is cut exactly once: its pieces tile it with no gap or overlap.
-        foreach (var (ringIndex, pieces) in piecesCut)
-        {
-            var ring = material.Rings[ringIndex];
-            var tabs = material.Tabs[ringIndex];
-            var tolerance = AdmittedClosureSlack(ring);
-            foreach (var start in SpanStarts(tabs))
-            {
-                var length = Span(ring, tabs, start).Sum(c => c.Length);
-                var at = 0.0;
-                foreach (var piece in pieces.Where(p => p.Span == start).OrderBy(p => p.From))
-                {
-                    if (System.Math.Abs(piece.From - at) > tolerance)
-                        return false;
-                    at = piece.To;
-                }
-                if (System.Math.Abs(length - at) > tolerance)
-                    return false;
-            }
-            visited.Add(ringIndex);
-        }
         return visited.Count == material.Rings.Count - (material.HasDisplayPerimeter ? 1 : 0);
     }
 
@@ -139,41 +116,19 @@ internal static class ContourProgramVerifier
     private static List<int> SpanStarts(bool[] tabs) => Enumerable.Range(0, tabs.Length)
         .Where(i => !tabs[i] && tabs[(i + tabs.Length - 1) % tabs.Length]).ToList();
 
-    // What a run along a tabbed ring cuts: its span (by the span's first curve) and where along the
+    // A run that starts exactly where a span between tabs starts and covers that span exactly,
-    // span it starts and ends. Null unless the run follows the ring from its start without
+    // stopping at the next tab.
-    // reaching past the span's next tab.
+    private static bool CutsTabbedSpan(IReadOnlyList<Curve> run, IReadOnlyList<Curve> ring, bool[] tabs,
-    private static (int Span, double From, double To)? CutTabbedSpan(IReadOnlyList<Curve> run,
+        int entityIndex, CancellationToken token, ref int budget)
-        IReadOnlyList<Curve> ring, bool[] tabs, int entityIndex, CancellationToken token, ref int budget)
     {
-        if (tabs[entityIndex])
-            return null;
         var tolerance = AdmittedClosureSlack(ring);
-        var count = tabs.Length;
+        if (!SpanStarts(tabs).Contains(entityIndex) || ring[entityIndex].DistanceAlong(run[0].Start) > tolerance)
-        var start = entityIndex;
+            return false;
-        var from = ring[entityIndex].DistanceAlong(run[0].Start);
-        for (var guard = 0; guard < count && !tabs[(start + count - 1) % count]; guard++)
-        {
-            start = (start + count - 1) % count;
-            from += ring[start].Length;
-        }
-        var rest = new List<Curve>();
-        for (var e = entityIndex; !tabs[e % count] && rest.Count < count; e++)
-            rest.Add(ring[e % count]);
-        var length = run.Sum(c => c.Length);
-        var offset = ring[entityIndex].DistanceAlong(run[0].Start);
-        if (length > rest.Sum(c => c.Length) - offset + tolerance
-            || !Follows(run, rest, 0, offset, false, tolerance, token, ref budget, partial: true))
-            return null;
-        return (start, from, from + length);
-    }
-
-    // The curves of the span between tabs that starts at curve start.
-    private static List<Curve> Span(IReadOnlyList<Curve> ring, bool[] tabs, int start)
-    {
         var span = new List<Curve>();
-        for (var e = start; !tabs[e % tabs.Length] && span.Count < tabs.Length; e++)
+        for (var e = entityIndex; !tabs[e % tabs.Length]; e++)
             span.Add(ring[e % tabs.Length]);
-        return span;
+        return System.Math.Abs(run.Sum(c => c.Length) - span.Sum(c => c.Length)) <= tolerance
+            && Follows(run, span, 0, 0, false, tolerance, token, ref budget);
     }
 
     // Zero for an exactly closed ring: a ring may lawfully close within the nominal closure
@@ -208,10 +163,8 @@ internal static class ContourProgramVerifier
     // collinear moves and a cyclic ring's reindexing do not change coverage.
     // `tolerance` is the admitted positional slack for this pair of streams (the exact epsilon
     // unless the nominal ring closes only within the nominal closure tolerance).
-    // `partial` accepts an actual stream that ends before the expected one does.
     private static bool Follows(IReadOnlyList<Curve> actual, IReadOnlyList<Curve> expected,
-        int index, double offset, bool cyclic, double tolerance, CancellationToken token, ref int budget,
+        int index, double offset, bool cyclic, double tolerance, CancellationToken token, ref int budget)
-        bool partial = false)
     {
         foreach (var curve in actual)
         {
@@ -248,7 +201,7 @@ internal static class ContourProgramVerifier
                 }
             }
         }
-        return cyclic || partial || index == expected.Count || index == expected.Count - 1
+        return cyclic || index == expected.Count || index == expected.Count - 1
             && expected[index].Length - offset <= tolerance;
     }
 

OpenNest.Core/CNC/CuttingPlanning/CuttingPlanCommit.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using OpenNest.CNC.CuttingStrategy;
-using OpenNest.CutOffs;
 using OpenNest.Geometry;
 
 namespace OpenNest.CNC.CuttingPlanning;
@@ -63,7 +62,7 @@ public enum CuttingCommitStatus
     Applied,
     Stale,
     InvalidInput,
-    Canceled,
+    Cancelled,
     Failed
 }
 
@@ -108,7 +107,7 @@ internal static class CuttingPlanCommit
         Action<Plate, Part> beforeInstall)
     {
         if (token.IsCancellationRequested)
-            return new(CuttingCommitStatus.Canceled, "Canceled before commit.");
+            return new(CuttingCommitStatus.Cancelled, "Cancelled before commit.");
         var scope = plans?.ToArray();
         if (scope == null || scope.Length == 0 || scope.Any(p => p?.Expected == null || p.Order == null))
             return Invalid(null, "A nonempty set of captured plate plans is required.");
@@ -127,7 +126,7 @@ internal static class CuttingPlanCommit
             }
             catch (OperationCanceledException)
             {
-                return new(CuttingCommitStatus.Canceled, "Canceled before commit.");
+                return new(CuttingCommitStatus.Cancelled, "Cancelled before commit.");
             }
             if (difference != null)
                 return new(CuttingCommitStatus.Stale, difference, plan.Expected.Plate);
@@ -201,7 +200,7 @@ internal static class CuttingPlanCommit
 
         // Last cancellation point. The boundary below has no await, search or geometry work.
         if (token.IsCancellationRequested)
-            return new(CuttingCommitStatus.Canceled, "Canceled before commit.");
+            return new(CuttingCommitStatus.Cancelled, "Cancelled before commit.");
 
         var undo = new List<(Plate Plate, Part[] Order, (Part Part, PartCuttingState State)[] States,
             (CutOff CutOff, bool FarEdgeFirst, Program Program)[] CutOffs)>();

OpenNest.Core/CNC/CuttingPlanning/ExecutionMotionReader.cs

@@ -27,12 +27,10 @@ public static class ExecutionMotionReader
         var moves = new List<ExecutionMotion>();
         var visiting = new HashSet<Program>(ReferenceEqualityComparer.Instance);
         var budget = 1000000;
-        Walk(program, origin, previous, false, null);
+        Walk(program, origin, previous);
         return new OwnedExecution(moves);
 
-        // raiseArrival: a marked call raises the head for the rapid that arrives at its first motion.
+        Vector Walk(Program current, Vector frame, Vector? arrival)
-        // callCode: the part's own code that called this sub-program, or null for the part's own codes.
-        Vector Walk(Program current, Vector frame, Vector? arrival, bool raiseArrival, int? callCode)
         {
             token.ThrowIfCancellationRequested();
             PostVerificationGeometry.Validate(frame);
@@ -43,10 +41,8 @@ public static class ExecutionMotionReader
             var pos = frame;
             var first = true;
             var countBefore = moves.Count;
-            var raised = HeadRaise.RaisedMask(current.Codes);
+            foreach (var code in current.Codes)
-            for (var codeIndex = 0; codeIndex < current.Codes.Count; codeIndex++)
             {
-                var code = current.Codes[codeIndex];
                 token.ThrowIfCancellationRequested();
                 if (--budget < 0)
                     throw new ArgumentException("Program expansion exceeds the verification limit.");
@@ -74,8 +70,7 @@ public static class ExecutionMotionReader
                         throw new ArgumentException("Subprogram rotation is not finite.");
                     // Call rotation is baked into the shared program by its setter. Do not
                     // rotate again; offsets are frame-relative even in incremental mode.
-                    pos = Walk(call.Program, frame + call.Offset, first ? arrival : pos,
+                    pos = Walk(call.Program, frame + call.Offset, first ? arrival : pos);
-                        raised[codeIndex] || first && raiseArrival, callCode ?? codeIndex);
                     first = false;
                     continue;
                 }
@@ -96,7 +91,7 @@ public static class ExecutionMotionReader
                 PostVerificationGeometry.Validate(end);
                 var rapid = motion is RapidMove;
                 if (first && !rapid)
-                    moves.Add(new(arrival, frame, true, LayerType.Display, null, raiseArrival, callCode: callCode));
+                    moves.Add(new(arrival, frame, true, LayerType.Display, null));
                 var start = first && rapid ? arrival : pos;
                 var layer = motion switch
                 {
@@ -111,8 +106,7 @@ public static class ExecutionMotionReader
                 var curve = rapid ? null : PostVerificationGeometry.Curve.Create(pos, end,
                     motion is ArcMove arcMove ? reference + arcMove.CenterPoint : null,
                     motion is ArcMove { Rotation: RotationType.CW });
-                moves.Add(new(start, end, rapid, layer, curve, raised[codeIndex] || first && rapid && raiseArrival,
+                moves.Add(new(start, end, rapid, layer, curve));
-                    ReferenceEquals(current, program) ? codeIndex : null, callCode));
                 pos = end;
                 first = false;
             }

OpenNest.Core/CNC/CuttingPlanning/FixedLeadReview.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
-using OpenNest.Clamps;
 using OpenNest.CNC.CuttingStrategy;
 using OpenNest.Diagnostics;
 using OpenNest.Geometry;

OpenNest.Core/CNC/CuttingPlanning/IncrementalClosureDrift.cs

@@ -79,7 +79,7 @@ internal static class IncrementalClosureDrift
         var endPoint = last.EndPoint + correction;
         if (last is ArcMove arc)
         {
-            // Keep the arc's center (relative to its start) equidistant from its moved end.
+            // Keep the arc's centre (relative to its start) equidistant from its moved end.
             var chord = endPoint.DistanceTo(new Vector());
             if (chord <= Tolerance.Epsilon)
                 return false;

OpenNest.Core/CNC/CuttingPlanning/LeadMaterialSnapshot.cs

@@ -51,12 +51,7 @@ public sealed class LeadMaterialSnapshot
     /// <summary>Capture a stable, clean, rotation-baked program, applying location once.
     /// Unsupported or malformed geometry produces an incomplete snapshot; cancellation throws.</summary>
     public static LeadMaterialSnapshot Capture(Program cleanProgram, Vector location,
-        CancellationToken token = default) => Capture(cleanProgram, location, token, sharedSpans: false);
+        CancellationToken token = default)
-
-    /// <param name="sharedSpans">A common-line member's clean program (docs/common-line-cutting.md):
-    /// its perimeter may carry Tab spans, the shared spans the member never cuts.</param>
-    internal static LeadMaterialSnapshot Capture(Program cleanProgram, Vector location,
-        CancellationToken token, bool sharedSpans)
     {
         try
         {
@@ -126,16 +121,11 @@ public sealed class LeadMaterialSnapshot
                         ? "A display perimeter must enclose every other contour."
                         : $"Material boundaries overlap, touch or self-intersect ({r}:{i}, {s}:{j}, overlap={overlap}).");
             }
-            // A ring encloses a point only inside the union of its curves' extents (each at least
-            // the curve's own reach), so a part with thousands of holes asks parity only where it can hold.
-            var ringExtents = rings.Select(ring => ring.Aggregate(PostVerificationGeometry.Extent.None,
-                (extent, curve) => extent.Union(curve.Extent))).ToArray();
-            bool Encloses(int ring, Vector point) => ringExtents[ring].Contains(point) && Inside(point, rings[ring], token);
             var outer = -1;
             for (var i = 0; i < rings.Count; i++)
             {
                 token.ThrowIfCancellationRequested();
-                if (Enumerable.Range(0, rings.Count).All(j => i == j || Encloses(i, rings[j][0].Start)))
+                if (Enumerable.Range(0, rings.Count).All(j => i == j || Inside(rings[j][0].Start, rings[i], token)))
                 {
                     if (outer >= 0)
                         throw new ArgumentException("Material perimeter is ambiguous.");
@@ -146,17 +136,16 @@ public sealed class LeadMaterialSnapshot
                 throw new ArgumentException(ringDisplay.Contains(true)
                     ? "A display perimeter must enclose every other contour."
                     : "Material must have exactly one enclosing perimeter.");
-            if (!sharedSpans && ringTabs[outer].Any(tab => tab))
+            if (ringTabs[outer].Any(tab => tab))
                 throw new ArgumentException("A perimeter cannot have tabs.");
             if (ringDisplay.Where((_, i) => i != outer).Any(display => display))
                 throw new ArgumentException("A display perimeter must enclose every other contour.");
             if (ringDisplay[outer] && rings.Count == 1)
                 throw new ArgumentException("A display perimeter with no cutouts has nothing to cut.");
-            var holeRings = Enumerable.Range(0, rings.Count).Where(i => i != outer).ToArray();
+            var holes = rings.Where((_, i) => i != outer).ToArray();
-            var holes = holeRings.Select(i => rings[i]).ToArray();
+            for (var i = 0; i < holes.Length; i++)
-            for (var i = 0; i < holeRings.Length; i++)
+                for (var j = i + 1; j < holes.Length; j++)
-                for (var j = i + 1; j < holeRings.Length; j++)
+                    if (Inside(holes[i][0].Start, holes[j], token) || Inside(holes[j][0].Start, holes[i], token))
-                    if (Encloses(holeRings[j], holes[i][0].Start) || Encloses(holeRings[i], holes[j][0].Start))
                         throw new ArgumentException("Nested cutouts are not supported material.");
             return new LeadMaterialSnapshot(new[] { rings[outer] }.Concat(holes).ToArray(),
                 new[] { ringTabs[outer] }.Concat(ringTabs.Where((_, i) => i != outer)).ToArray(), null, ringDisplay[outer]);

OpenNest.Core/CNC/CuttingPlanning/LeadPathValidator.cs

@@ -65,17 +65,6 @@ public static class LeadPathValidator
             {
                 token.ThrowIfCancellationRequested();
                 var move = execution.Motions[i];
-                if (!move.Rapid && move.Layer == LayerType.CommonLine)
-                {
-                    // A shared cut runs in the kerf between two parts: it may touch no material at all.
-                    var (shared, sharedObstacle) = CheckSharedCut(i);
-                    if (shared == null)
-                        continue;
-                    if (isFixed?.Invoke(i) != true || fixedFailures == null)
-                        return shared;
-                    fixedFailures.Add(new(i, shared, sharedObstacle));
-                    continue;
-                }
                 if (move.Layer is not (LayerType.Leadin or LayerType.Leadout))
                     continue;
                 var (failure, obstacle) = CheckMotion(i);
@@ -89,27 +78,6 @@ public static class LeadPathValidator
             // checks rapid travel and contour accounting for the complete program.
             return new(true, true, null);
 
-            (LeadPathValidationResult Failure, int? Obstacle) CheckSharedCut(int i)
-            {
-                var move = execution.Motions[i];
-                if (move.Curve == null || !double.IsFinite(move.Length) || move.Length <= PostVerificationGeometry.Epsilon)
-                    return (new(false, false, "A common-line shared cut is missing, degenerate or inconsistent."), null);
-                if (MaterialContact(move.Curve, target, null, ref budget, token) is { } own)
-                    return (new(true, false, $"Common-line shared cut {i} contacts its own part's material ({own}). "
-                        + "Rejoin the parts one kerf apart, then replan."), null);
-                for (var other = 0; other < otherMaterials.Count; other++)
-                {
-                    token.ThrowIfCancellationRequested();
-                    var material = otherMaterials[other];
-                    if (ReferenceEquals(material, target) || move.Curve.Extent.IsClearOfQueriesFrom(material.Extent))
-                        continue;
-                    if (MaterialContact(move.Curve, material, null, ref budget, token) != null)
-                        return (new(true, false, "A common-line shared cut contacts or enters another placed material. "
-                            + "Rejoin the parts one kerf apart at the current kerf, then replan."), other);
-                }
-                return (null, null);
-            }
-
             (LeadPathValidationResult Failure, int? Obstacle) CheckMotion(int i)
             {
                 var move = execution.Motions[i];
@@ -132,7 +100,6 @@ public static class LeadPathValidator
                 var adjacentIndex = groupEdge + step;
                 var genuineJoint = false;
                 var breakLead = false;
-                var sharedLead = false;
                 if (adjacentIndex >= 0 && adjacentIndex < execution.Motions.Count)
                 {
                     var adjacent = execution.Motions[adjacentIndex];
@@ -152,20 +119,6 @@ public static class LeadPathValidator
                                 allowed = joint;
                         }
                     }
-                    // A shared cut lies in the kerf between two parts, so its lead joins no boundary
-                    // and may touch none: its joint is the cut's own start (or end for a lead-out).
-                    else if (!adjacent.Rapid && adjacent.Layer == LayerType.CommonLine
-                        && adjacent.Curve != null && adjacent.Length > PostVerificationGeometry.Epsilon)
-                    {
-                        var edge = execution.Motions[groupEdge];
-                        var joint = move.Layer == LayerType.Leadin ? edge.End : edge.Curve.Start;
-                        var cutJoint = move.Layer == LayerType.Leadin ? adjacent.Curve.Start : adjacent.End;
-                        if (joint.DistanceTo(cutJoint) <= PostVerificationGeometry.Epsilon)
-                        {
-                            genuineJoint = true;
-                            sharedLead = true;
-                        }
-                    }
                     else if (!adjacent.Rapid && adjacent.Layer is LayerType.Cut or LayerType.Display
                         && adjacent.Curve != null && adjacent.Length > PostVerificationGeometry.Epsilon)
                     {
@@ -201,13 +154,11 @@ public static class LeadPathValidator
                 // material is expected there, but touching any of its boundaries is not.
                 var failure = breakLead
                     ? MaterialContact(move.Curve, target, null, ref budget, token, allowInterior: true)
-                    : CheckMaterial(target, sharedLead ? null : allowed);
+                    : CheckMaterial(target, allowed);
                 if (failure != null)
                     return (new(true, false, breakLead
                         ? $"Break cut lead motion {i} contacts its part's boundary ({failure}). Try a shorter lead-in or move the tabs."
-                        : sharedLead
+                        : $"Lead motion {i} contacts or enters target material outside its adjacent contour joint ({failure})."), null);
-                            ? $"Common-line lead motion {i} contacts its part's material ({failure}). The lead runs along the shared line: shorten the lead-in or lead-out, or cut the common lines twice."
-                            : $"Lead motion {i} contacts or enters target material outside its adjacent contour joint ({failure})."), null);
                 var reach = move.Curve.Extent;
                 for (var other = 0; other < otherMaterials.Count; other++)
                 {
@@ -343,25 +294,13 @@ public static class LeadPathValidator
             if (--budget < 0)
                 throw new NotSupportedException("Lead validation exceeds the native query limit.");
             var contacts = curve.Contacts(boundary, out var overlap);
-            if (overlap || contacts.Any(p => permittedJoint is not { } joint || !AtJoint(p, joint, boundary)))
+            if (overlap || contacts.Any(p => permittedJoint is not { } joint
+                || p.DistanceTo(joint) > PostVerificationGeometry.Epsilon))
                 return $"boundary; allowed={permittedJoint}; contacts={string.Join(";", contacts)}; overlap={overlap}";
         }
         // With all other boundary contacts excluded, the connected open path
         // has constant material membership. Use the native arc midpoint, not
         // the chord midpoint or endpoints (which can both lie in scrap).
         return !allowInterior && material.ContainsMaterial(curve.Midpoint, token) ? "interior" : null;
-
-        // A lead tangent to the boundary it joins (an arc lead-in meeting a straight edge) has a
-        // double root at the joint that rounding splits into two contacts a few 1e-8 apart; one
-        // within JointTolerance of a joint the boundary itself passes through is still the joint.
-        static bool AtJoint(Vector point, Vector joint, PostVerificationGeometry.Curve boundary)
-        {
-            var distance = point.DistanceTo(joint);
-            return distance <= PostVerificationGeometry.Epsilon
-                || distance <= JointTolerance && boundary.Contains(joint);
-        }
     }
-
-    // As SlideContact's: far below any kerf, far above a tangent root's rounding drift.
-    private const double JointTolerance = 1e-6;
 }

OpenNest.Core/CNC/CuttingPlanning/NestedPartContainment.cs

@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using OpenNest.Geometry;
+using OpenNest.Math;
 
 namespace OpenNest.CNC.CuttingPlanning;
 
@@ -55,4 +56,17 @@ internal static class NestedPartContainment
         ExecutionMotionReader.ReadSupported(clean, location, null, token).Motions
             .Where(m => !m.Rapid && m.Layer is LayerType.Cut or LayerType.Display or LayerType.DisplayPerimeter && m.Curve != null)
             .Select(m => m.Curve.ToEntity().BoundingBox).ToList().GetBoundingBox();
+
+    /// <summary>Whether a host's bounds admit an inner part's bounds as a containment candidate.</summary>
+    internal static bool Within(Box inner, Box outer) =>
+        inner.Left >= outer.Left - Tolerance.Epsilon && inner.Right <= outer.Right + Tolerance.Epsilon
+        && inner.Bottom >= outer.Bottom - Tolerance.Epsilon && inner.Top <= outer.Top + Tolerance.Epsilon;
+
+    /// <summary>The union of two boxes.</summary>
+    internal static Box Union(Box a, Box b)
+    {
+        var left = System.Math.Min(a.Left, b.Left);
+        var bottom = System.Math.Min(a.Bottom, b.Bottom);
+        return new(left, bottom, System.Math.Max(a.Right, b.Right) - left, System.Math.Max(a.Top, b.Top) - bottom);
+    }
 }

OpenNest.Core/CNC/CuttingPlanning/NestedPartReview.cs

@@ -37,7 +37,7 @@ internal static class NestedPartReview
                     continue;
                 var program = FixedLeadReview.Clean(part);
                 cleanBounds[index] = NestedPartContainment.CleanBounds(program, part.Location, token);
-                hostBounds[index] = BoundingBox.Union(part.BoundingBox, cleanBounds[index]);
+                hostBounds[index] = NestedPartContainment.Union(part.BoundingBox, cleanBounds[index]);
                 clean[index] = program;
             }
             catch (Exception exception) when (IsInvalid(exception))
@@ -52,7 +52,7 @@ internal static class NestedPartReview
             {
                 token.ThrowIfCancellationRequested();
                 if (inner == host || clean[inner] == null || clean[host] == null
-                    || !BoundingBox.IsWithin(cleanBounds[inner], hostBounds[host]))
+                    || !NestedPartContainment.Within(cleanBounds[inner], hostBounds[host]))
                     continue;
                 var inside = NestedPartContainment.InsideCutout(Material(inner), Material(host), token,
                     out var ambiguity);

OpenNest.Core/CNC/CuttingPlanning/OwnedCuttingParameters.cs

@@ -42,11 +42,9 @@ internal static class OwnedCuttingParameters
                 : CopyTab(source.TabConfig),
             TabsEnabled = source.TabsEnabled,
             SupportTabs = source.SupportTabs,
-            TabBySize = source.TabBySize,
+            NoBedTabMinWidth = Dimension(source.NoBedTabMinWidth),
-            TabSizeMinWidth = Dimension(source.TabSizeMinWidth),
+            NoBedTabMaxWidth = Dimension(source.NoBedTabMaxWidth),
-            TabSizeMaxWidth = Dimension(source.TabSizeMaxWidth),
             TabHeldMaxLength = Dimension(source.TabHeldMaxLength),
-            SliceTippingSlugs = source.SliceTippingSlugs,
             Sequencing = new SequenceParameters
             {
                 Method = sequence.Method,

OpenNest.Core/CNC/CuttingPlanning/OwnedExecution.cs

@@ -38,38 +38,20 @@ public sealed class OwnedExecution
 public sealed class ExecutionMotion
 {
     internal ExecutionMotion(Vector? start, Vector end, bool rapid, LayerType layer,
-        PostVerificationGeometry.Curve curve, bool headRaised = false, int? code = null, int? callCode = null)
+        PostVerificationGeometry.Curve curve)
     {
         Start = start;
         End = end;
         Rapid = rapid;
         Layer = layer;
         Curve = curve;
-        HeadRaised = headRaised;
-        Code = code;
-        CallCode = callCode;
     }
 
     public Vector? Start { get; }
     public Vector End { get; }
     public bool Rapid { get; }
     public LayerType Layer { get; }
-
-    /// <summary>A rapid made with the head raised over parts already cut (<see cref="HeadRaise"/>).</summary>
-    public bool HeadRaised { get; }
-
-    /// <summary>
-    /// The index of the code this motion runs in the read program's own codes; null for a motion
-    /// inside a sub-program and for the rapid a program that opens with a cut is given.
-    /// </summary>
-    public int? Code { get; }
-
-    /// <summary>
-    /// For a motion inside a sub-program, the index of the read program's own call that runs it;
-    /// null for the program's own motions.
-    /// </summary>
-    internal int? CallCode { get; }
     public double Length => Curve?.Length ?? 0;
     internal PostVerificationGeometry.Curve Curve { get; }
-    internal ExecutionMotion WithStart(Vector? start) => new(start, End, Rapid, Layer, Curve, HeadRaised, Code, CallCode);
+    internal ExecutionMotion WithStart(Vector? start) => new(start, End, Rapid, Layer, Curve);
 }

OpenNest.Core/CNC/CuttingPlanning/PlateCuttingState.cs

@@ -4,8 +4,6 @@ using System.Linq;
 using System.Threading;
 using OpenNest.CNC.CuttingStrategy;
 using OpenNest.Collections;
-using OpenNest.CommonLines;
-using OpenNest.CutOffs;
 using OpenNest.Geometry;
 
 namespace OpenNest.CNC.CuttingPlanning;
@@ -29,17 +27,10 @@ public sealed class PlateCuttingState
     private readonly Dictionary<Drawing, DrawingRecord> drawings;
     private readonly Dictionary<CuttingParameters, string> settings;
     private readonly CuttingParameters plateSettings;
-    private readonly ObservableList<CommonLineGroup> commonLineList;
-    private readonly CommonLineRecord[] commonLines;
-    private readonly bool cutCommonLinesTwice;
 
     private PlateCuttingState(Plate plate, PartRecord[] parts, CutOffRecord[] cutOffs,
         Dictionary<Drawing, DrawingRecord> drawings, Dictionary<CuttingParameters, string> settings)
     {
-        commonLineList = plate.CommonLines;
-        commonLines = plate.CommonLines.Select(group => new CommonLineRecord(group, group.Kerf,
-            group.Members.ToArray())).ToArray();
-        cutCommonLinesTwice = plate.CutCommonLinesTwice;
         this.settings = settings;
         plateSettings = plate.CuttingParameters;
         Plate = plate;
@@ -91,7 +82,7 @@ public sealed class PlateCuttingState
         }
         var cutOffs = plate.CutOffs.Select(c => c == null
             ? throw new ArgumentException("Plate contains a missing cutoff definition.")
-            : new CutOffRecord(c, c.Drawing, c.Axis, c.Position, c.StartLimit, c.EndLimit, c.Gaps,
+            : new CutOffRecord(c, c.Drawing, c.Axis, c.Position, c.StartLimit, c.EndLimit,
                 c.HeadLockOvercut, c.FarEdgeFirst)).ToArray();
         return new(plate, records.ToArray(), cutOffs, drawings, settings);
 
@@ -166,23 +157,9 @@ public sealed class PlateCuttingState
                 || cutOff.Axis != record.Axis || !Bits(cutOff.Position.X, record.Position.X)
                 || !Bits(cutOff.Position.Y, record.Position.Y)
                 || !Bits(cutOff.StartLimit, record.StartLimit) || !Bits(cutOff.EndLimit, record.EndLimit)
-                // Gaps are replaced, never edited in place, so the reference decides.
-                || !ReferenceEquals(cutOff.Gaps, record.Gaps)
                 || !Bits(cutOff.HeadLockOvercut, record.HeadLockOvercut) || cutOff.FarEdgeFirst != record.FarEdgeFirst)
                 return $"Cutoff {i + 1} definition changed.";
         }
-        // Common lines decide which edges each member cuts, and whether they are cut once.
-        if (!ReferenceEquals(plate.CommonLines, commonLineList) || plate.CutCommonLinesTwice != cutCommonLinesTwice
-            || plate.CommonLines.Count != commonLines.Length)
-            return "Common lines changed.";
-        for (var i = 0; i < commonLines.Length; i++)
-        {
-            var record = commonLines[i];
-            var group = plate.CommonLines[i];
-            if (!ReferenceEquals(group, record.Group) || !Bits(group.Kerf, record.Kerf)
-                || !group.Members.SequenceEqual(record.Members, ReferenceEqualityComparer.Instance))
-                return $"Common line {i + 1} changed.";
-        }
         // Part.Rotation derives from the manual flag, PreLeadInRotation and Program.Rotation,
         // all compared exactly above.
         return null;
@@ -228,9 +205,6 @@ public sealed class PlateCuttingState
     private sealed record DrawingRecord(Program Program, Program Copy, bool IsCutOff,
         List<ContourCutPin> Pins, string PinsFingerprint);
 
-    private sealed record CommonLineRecord(CommonLineGroup Group, double Kerf, Part[] Members);
-
     private sealed record CutOffRecord(CutOff CutOff, Drawing Drawing, CutOffAxis Axis, Vector Position,
-        double? StartLimit, double? EndLimit, IReadOnlyList<CutOffGap> Gaps, double HeadLockOvercut,
+        double? StartLimit, double? EndLimit, double HeadLockOvercut, bool FarEdgeFirst);
-        bool FarEdgeFirst);
 }

OpenNest.Core/CNC/CuttingPlanning/PreparedContours.cs

@@ -5,7 +5,6 @@ using System.Threading;
 using OpenNest.CNC.CuttingStrategy;
 using OpenNest.Diagnostics;
 using OpenNest.Geometry;
-using OpenNest.Math;
 using OpenNest.Support;
 
 namespace OpenNest.CNC.CuttingPlanning;
@@ -25,23 +24,6 @@ public sealed record ContourChoice(int ContourOrdinal, int EntityOrdinal, Vector
     public Vector? Pierce { get; internal init; }
 }
 
-/// <summary>
-/// How a common-line member's outside is cut once (see docs/common-line-cutting.md), with the
-/// group's kerf. The member cuts its outside compensated, so each shared edge it cuts lands on the
-/// kerf centerline: that edge is the common line. Spans an earlier member cut carry the Tab layer
-/// and are never cut again. A member that cuts a common line itself (<see cref="Entry"/> set)
-/// starts there: at <see cref="Entry"/> (part coordinates), the vertex where its shared edge
-/// begins, with a straight lead-in from <see cref="Pierce"/> along that edge's axis, and runs on
-/// round its perimeter with no lead-out, closing at the entry or stopping in an earlier member's
-/// kerf. Its other stretches, and every stretch of a member without an entry, are remainder pieces
-/// entered in the kerf before them.
-/// </summary>
-public sealed record CommonLinePerimeter(double Kerf, Vector? Entry = null, Vector? Pierce = null)
-{
-    /// <summary>Whether the member starts its outside on a common line it cuts.</summary>
-    public bool StartsOnCommonLine => Entry != null;
-}
-
 /// <summary>
 /// Immutable owned clean contours and settings. Callers supply the clean, already-rotated
 /// program and keep it stable during Capture. This is not a topology or lead-path verdict.
@@ -57,11 +39,6 @@ public sealed class PreparedContours
     // Closed cutouts with tab spans, in program order. Like break cuts they are not choices:
     // every full or prefix emission cuts their pieces after the break cuts.
     private readonly List<Shape> tabbedCutouts;
-    // Slices of the slugs the support bed cannot hold level, in cutting order: open cuts inside
-    // their cutouts, cut right after the break cuts so every slug is sliced before its cutout.
-    private readonly IReadOnlyList<SlugSlice> slugSlices;
-    // Pierce-zone resolutions by contour, shared with every copy: the contours are the same by ordinal.
-    private readonly PierceZoneMemo pierceZones;
     // By contour ordinal; all null without pins. A pinned contour has exactly one entry and
     // its own owned settings (the pin's lead-in, lead-out and tab).
     private readonly ContourChoice[] pinned;
@@ -76,10 +53,6 @@ public sealed class PreparedContours
     // never-executed DisplayPerimeterTail. Null for an ordinary cut perimeter.
     private readonly Shape displayOutline;
     private bool hasCutPerimeter => displayOutline == null;
-    // Set for a common-line member, cut from one fixed entry: its whole perimeter from where its
-    // first shared edge begins, or its remainder pieces between the Tab spans earlier members cut.
-    private readonly CommonLinePerimeter commonLine;
-    private readonly ContourChoice commonLineEntry;
 
     private PreparedContours(Shape[] shapes, List<Entity> scribes, List<Shape> breakCuts, List<Shape> tabbedCutouts,
         CuttingParameters parameters)
@@ -88,13 +61,9 @@ public sealed class PreparedContours
     }
 
     private PreparedContours(Shape[] shapes, List<Entity> scribes, List<Shape> breakCuts, List<Shape> tabbedCutouts,
-        CuttingParameters parameters, Shape displayOutline, PierceZoneMemo pierceZones = null,
+        CuttingParameters parameters, Shape displayOutline)
-        CommonLinePerimeter commonLine = null, IReadOnlyList<SlugSlice> slugSlices = null)
     {
-        this.slugSlices = slugSlices ?? Array.Empty<SlugSlice>();
-        this.pierceZones = pierceZones ?? new PierceZoneMemo();
         this.displayOutline = displayOutline;
-        this.commonLine = commonLine;
         this.shapes = shapes;
         this.scribes = scribes;
         this.breakCuts = breakCuts;
@@ -102,31 +71,11 @@ public sealed class PreparedContours
         this.parameters = parameters;
         pinned = new ContourChoice[shapes.Length];
         pinNumbers = new int[shapes.Length];
-        if (commonLine is { Entry: { } entry })
-        {
-            // The outside starts where a shared edge it cuts begins, pierced off it.
-            var perimeter = shapes[^1];
-            var entity = perimeter.Entities.FindIndex(e => e.Layer != SpecialLayers.Tab
-                && Start(e).DistanceTo(entry) <= PostVerificationGeometry.Epsilon);
-            commonLineEntry = new ContourChoice(shapes.Length - 1, entity, Start(perimeter.Entities[entity]))
-            {
-                Owner = this,
-                Pierce = commonLine.Pierce,
-            };
-        }
-        else if (commonLine != null)
-        {
-            // The remainder's first piece starts where a shared span ends: the one fixed entry.
-            var perimeter = shapes[^1];
-            var first = ContourCuttingStrategy.TabbedCutoutPieces(perimeter)[0].Entities[0];
-            var entity = perimeter.Entities.IndexOf(first);
-            commonLineEntry = new ContourChoice(shapes.Length - 1, entity, Start(first)) { Owner = this };
-        }
     }
 
     private PreparedContours(PreparedContours unpinned, IReadOnlyList<CutPinResolution> pins, CancellationToken token)
         : this(unpinned.shapes, unpinned.scribes, unpinned.breakCuts, unpinned.tabbedCutouts, unpinned.parameters,
-            unpinned.displayOutline, unpinned.pierceZones, unpinned.commonLine, unpinned.slugSlices)
+            unpinned.displayOutline)
     {
         contourParameters = new CuttingParameters[shapes.Length];
         var rejected = new List<CutPinResolution>();
@@ -143,9 +92,8 @@ public sealed class PreparedContours
                 throw new ArgumentException("A pin resolution does not belong to these contours.", nameof(pins));
             if (pinned[contour] != null)
                 throw new ArgumentException("Two pins resolve to one contour.", nameof(pins));
-            // The emitter tabs only the outside, so a tab elsewhere cannot be cut as pinned. A
+            // The emitter tabs only the outside, so a tab elsewhere cannot be cut as pinned.
-            // common-line member's outside is cut from its shared spans, never from a pin.
+            if (pin.Pin.HasTab && contour != PerimeterOrdinal)
-            if (pin.Pin.HasTab && contour != PerimeterOrdinal || commonLine != null && contour == PerimeterOrdinal)
             {
                 rejected.Add(pin);
                 continue;
@@ -165,7 +113,7 @@ public sealed class PreparedContours
     // a pinned perimeter keeps its pin's settings: the analysis is only kept for review.
     private PreparedContours(PreparedContours source, PartSupport support, Vector location, Tab tab)
         : this(source.shapes, source.scribes, source.breakCuts, source.tabbedCutouts, source.parameters,
-            source.displayOutline, source.pierceZones, source.commonLine, source.slugSlices)
+            source.displayOutline)
     {
         for (var contour = 0; contour < Count; contour++)
         {
@@ -204,84 +152,9 @@ public sealed class PreparedContours
             throw new ArgumentException("Support tabs need a complete analysis with a tab point.", nameof(support));
         if (!hasCutPerimeter)
             throw new ArgumentException("A display perimeter is never cut, so it cannot hold a support tab.", nameof(support));
-        if (commonLine != null)
-            throw new ArgumentException("A common-line member is never support-tabbed.", nameof(support));
         return new PreparedContours(this, support, location, tab);
     }
 
-    // A copy that slices slugs; everything else, pins and support analysis included, is kept.
-    private PreparedContours(PreparedContours source, IReadOnlyList<SlugSlice> slices)
-        : this(source.shapes, source.scribes, source.breakCuts, source.tabbedCutouts, source.parameters,
-            source.displayOutline, source.pierceZones, source.commonLine, slices)
-    {
-        for (var contour = 0; contour < Count; contour++)
-        {
-            pinned[contour] = source.pinned[contour] is { } pin ? pin with { Owner = this } : null;
-            pinNumbers[contour] = source.pinNumbers[contour];
-        }
-        contourParameters = (CuttingParameters[])source.contourParameters?.Clone();
-        RejectedPins = source.RejectedPins;
-        support = source.support;
-        supportOrigin = source.supportOrigin;
-    }
-
-    /// <summary>
-    /// A copy that slices the slug of each cutout <paramref name="bed"/> cannot hold level
-    /// (<see cref="SlugSlicer.Tips"/>), with the part placed at <paramref name="location"/> on a
-    /// sheet in <paramref name="quadrant"/>, along the bed's contact lines, each slice stopping the
-    /// kerf short of its cutout (docs/support-tabs.md#slug-slices). Every full or prefix emission
-    /// cuts the slices right after the break cuts, so each slug is sliced before its cutout.
-    /// A cutout that holds another of this part's cuts, or whose box holds one of
-    /// <paramref name="otherParts"/> (world boxes of the plate's other parts), is not sliced:
-    /// a slice would cut what is nested in it. Without a bed or a kerf, or with nothing to slice,
-    /// this preparation is returned unchanged.
-    /// </summary>
-    internal PreparedContours WithSlugSlices(SupportBed bed, int quadrant, Vector location,
-        IReadOnlyList<Box> otherParts, CancellationToken token = default)
-    {
-        ArgumentNullException.ThrowIfNull(otherParts);
-        PostVerificationGeometry.Validate(location);
-        var standoff = parameters.Kerf;
-        if (bed == null || !(standoff > 0) || !double.IsFinite(standoff))
-            return this;
-        // Pierced on the slice where the cutouts' own lead-in would pierce, and at least as far
-        // from the cutout as any pierce keeps from its contour.
-        var clearance = parameters.GetEffectivePierceClearance();
-        var reach = System.Math.Max(clearance,
-            ContourCuttingStrategy.CommonLineLeadInReach(parameters.InternalLeadIn ?? new NoLeadIn()));
-        var slices = new List<SlugSlice>();
-        for (var ordinal = 0; ordinal < PerimeterOrdinal; ordinal++)
-        {
-            token.ThrowIfCancellationRequested();
-            var hole = shapes[ordinal];
-            var box = hole.BoundingBox;
-            var world = new Box(box.Left + location.X, box.Bottom + location.Y, box.Length, box.Width);
-            if (otherParts.Any(other => other != null && world.Contains(other)))
-                continue;
-            var polygon = hole.ToPolygonWithTolerance(SupportMaterial.ChordTolerance);
-            if (EnclosesOtherCuts(ordinal, polygon)
-                || !SlugSlicer.Tips(bed, quadrant, SupportMaterial.FromPolygons(polygon.Vertices.Select(v => v + location))))
-                continue;
-            slices.AddRange(SlugSlicer.Slices(bed, quadrant, polygon.Vertices, location, standoff, reach, clearance));
-        }
-        return slices.Count == 0 ? this : new PreparedContours(this, slices.AsReadOnly());
-    }
-
-    // Whether another contour, break cut or tabbed cutout of this part lies inside the cutout.
-    private bool EnclosesOtherCuts(int ordinal, Polygon cutout)
-    {
-        var others = shapes.Where((_, index) => index != ordinal && index != PerimeterOrdinal)
-            .Concat(breakCuts).Concat(tabbedCutouts);
-        return others.Any(other => other.Entities.Count > 0 && cutout.ContainsPoint(other.Entities[0] switch
-        {
-            Circle circle => circle.Center + new Vector(circle.Radius, 0),
-            var entity => Start(entity),
-        }));
-    }
-
-    /// <summary>The slug slices this preparation cuts after its break cuts and before its contours.</summary>
-    public IReadOnlyList<SlugSlice> SlugSlices => slugSlices;
-
     /// <summary>
     /// The analysis of a part its support bed cannot hold level (see <see cref="WithSupportTab"/>),
     /// or null; <see cref="SupportOrigin"/> places its local contours in its world frame.
@@ -292,24 +165,12 @@ public sealed class PreparedContours
     public Vector SupportOrigin => supportOrigin;
 
     /// <summary>Whether the emitted perimeter is tabbed: by the plate settings, its pin or support.</summary>
-    internal bool PerimeterTabbed => hasCutPerimeter && commonLine == null && ParametersFor(PerimeterOrdinal).TabsEnabled;
+    internal bool PerimeterTabbed => hasCutPerimeter && ParametersFor(PerimeterOrdinal).TabsEnabled;
-
-    /// <summary>
-    /// True for a common-line member (see <see cref="CommonLinePerimeter"/>): its perimeter has one
-    /// fixed entry and is emitted whole from its common line, or as its remainder pieces.
-    /// </summary>
-    public bool IsCommonLinePerimeter => commonLine != null;
-
-    /// <summary>How the member's outside is cut once, or null for any other part.</summary>
-    public CommonLinePerimeter CommonLine => commonLine;
 
     public int Count => shapes.Length;
 
     /// <summary>The pierce zone every lead-in pierce of these contours keeps; 0 when off.</summary>
     internal double PierceZoneRadius => parameters.GetPierceZoneRadius();
-
-    /// <summary>The pierce-zone resolutions these contours' emissions share; for tests.</summary>
-    internal PierceZoneMemo PierceZones => pierceZones;
     /// <summary>
     /// The cut perimeter, emitted after every hole; <see cref="Count"/> (no contour) when the outside
     /// is a display perimeter, so every contour below it is a hole.
@@ -319,7 +180,7 @@ public sealed class PreparedContours
     /// <summary>False when the outside is a display perimeter that is never cut: all contours are holes.</summary>
     public bool HasCutPerimeter => hasCutPerimeter;
 
-    /// <summary>Resolved pins this preparation could not honor: a tab on an internal contour.</summary>
+    /// <summary>Resolved pins this preparation could not honour: a tab on an internal contour.</summary>
     public IReadOnlyList<CutPinResolution> RejectedPins { get; } = Array.Empty<CutPinResolution>();
 
     /// <summary>True when a drawing pin fixes this contour's entry, leads and tab.</summary>
@@ -342,10 +203,10 @@ public sealed class PreparedContours
     /// contour keeps the automatic selection with <paramref name="parameters"/>.
     /// </summary>
     public static PreparedContours Capture(Program program, CuttingParameters parameters,
-        IReadOnlyList<CutPinResolution> pins, CancellationToken token = default, CommonLinePerimeter commonLine = null)
+        IReadOnlyList<CutPinResolution> pins, CancellationToken token = default)
     {
         ArgumentNullException.ThrowIfNull(pins);
-        var unpinned = Capture(program, parameters, token, commonLine);
+        var unpinned = Capture(program, parameters, token);
         return pins.Any(p => p?.IsResolved != false) ? new PreparedContours(unpinned, pins, token) : unpinned;
     }
 
@@ -367,12 +228,7 @@ public sealed class PreparedContours
 
     private CuttingParameters ParametersFor(int contourOrdinal) => contourParameters?[contourOrdinal] ?? parameters;
 
-    /// <param name="commonLine">For a common-line member: how its outside is cut once. With an
+    public static PreparedContours Capture(Program program, CuttingParameters parameters, CancellationToken token = default)
-    /// entry, the program's perimeter is closed and starts there. Without one, it must carry the
-    /// spans earlier members cut on the Tab layer (CommonLineCutting.MarkSharedSpans); it is then
-    /// the perimeter, cut in pieces between them, rather than a tabbed cutout.</param>
-    public static PreparedContours Capture(Program program, CuttingParameters parameters, CancellationToken token = default,
-        CommonLinePerimeter commonLine = null)
     {
         token.ThrowIfCancellationRequested();
         var ownedParameters = OwnedCuttingParameters.Copy(parameters);
@@ -435,60 +291,6 @@ public sealed class PreparedContours
             if (NominalContourClosure.IsClosed(Start(current.Entities[0]), End(entity)))
                 FinishContour();
         }
-        if (commonLine != null)
-        {
-            if (displayPerimeter != null || current.Entities.Count != 0)
-                throw new ArgumentException("A common-line member needs one closed cut perimeter.");
-            if (!double.IsFinite(commonLine.Kerf) || commonLine.Kerf <= 0
-                || (commonLine.Entry == null) != (commonLine.Pierce == null))
-                throw new ArgumentException("A common-line member needs a positive kerf, and an entry with its pierce.");
-            var outside = tabbedCutouts.Concat(contours).MaxBy(shape => shape.BoundingBox.Width * shape.BoundingBox.Length);
-            if (commonLine is { Entry: { } entry, Pierce: { } pierce })
-            {
-                // Cut from its entry vertex on a common line; every other contour lies inside it.
-                PostVerificationGeometry.Validate(entry);
-                PostVerificationGeometry.Validate(pierce);
-                if (outside == null
-                    || !outside.Entities.Exists(e => e.Layer != SpecialLayers.Tab
-                        && Start(e).DistanceTo(entry) <= PostVerificationGeometry.Epsilon)
-                    || pierce.DistanceTo(entry) <= PostVerificationGeometry.Epsilon)
-                    throw new ArgumentException("A common-line member's perimeter does not start at its common line.");
-                if (contours.Contains(outside))
-                {
-                    contours.Remove(outside);
-                    contours.Add(outside);
-                    foreach (var cut in breakCuts)
-                        cut.UpdateBounds();
-                    return new(contours.ToArray(), scribes, breakCuts, tabbedCutouts, ownedParameters, null, null,
-                        commonLine);
-                }
-            }
-            // The outside carries the shared spans earlier members cut as tabs; every other contour lies inside it.
-            else if (outside == null || !tabbedCutouts.Contains(outside)
-                || ContourCuttingStrategy.TabbedCutoutPieces(outside).Count == 0)
-                throw new ArgumentException("A common-line member's perimeter does not carry its shared spans.");
-            // Each remainder piece is pierced in the kerf of the span before it, the external
-            // lead-in's reach back along it: the span must be that long. Never shortened.
-            var reach = ContourCuttingStrategy.CommonLineLeadInReach(ownedParameters.ExternalLeadIn ?? new NoLeadIn());
-            if (reach <= OpenNest.Math.Tolerance.Epsilon)
-                throw new NotSupportedException("A common-line member's remainder needs a lead-in with length: "
-                    + "its compensation starts in the shared kerf along the lead-in. Choose an external lead-in "
-                    + "with length, or cut the common lines twice.");
-            foreach (var piece in ContourCuttingStrategy.TabbedCutoutPieces(outside))
-            {
-                var index = outside.Entities.IndexOf(piece.Entities[0]);
-                var span = outside.Entities[(index + outside.Entities.Count - 1) % outside.Entities.Count];
-                if (span is not Line line || line.Length < reach + PostVerificationGeometry.Epsilon)
-                    throw new NotSupportedException(FormattableString.Invariant(
-                        $"One of its shared spans is {span.Length:0.####} long, shorter than the {reach:0.####} external lead-in its remainder starts along in that span's kerf. Shorten the lead-in, or cut the common lines twice."));
-            }
-            tabbedCutouts.Remove(outside);
-            contours.Add(outside);
-            foreach (var cut in breakCuts)
-                cut.UpdateBounds();
-            return new(contours.ToArray(), scribes, breakCuts, tabbedCutouts, ownedParameters, null, null,
-                commonLine);
-        }
         if (displayPerimeter != null)
         {
             if (current.Entities.Count != 0)
@@ -558,8 +360,6 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return pin;
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return fixedEntry;
         var point = shape.ClosestPointTo(approach, out var entity);
         return Entry(contourOrdinal, shape.Entities.IndexOf(entity), point);
     }
@@ -578,8 +378,6 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return new[] { pin };
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return new[] { fixedEntry };
         var entries = new List<ContourChoice>();
         entries.Add(ClosestEntry(contourOrdinal, approach));
         for (var i = 0; i < shape.Entities.Count && entries.Count < maxEntries; i++)
@@ -589,8 +387,8 @@ public sealed class PreparedContours
             if (entity is Circle circle)
             {
                 for (var angle = 0; angle < 8 && entries.Count < maxEntries; angle++)
-                    Add(i, circle.Center + new Vector(PortableMath.Cos(angle * System.Math.PI / 4),
+                    Add(i, circle.Center + new Vector(System.Math.Cos(angle * System.Math.PI / 4),
-                        PortableMath.Sin(angle * System.Math.PI / 4)) * circle.Radius);
+                        System.Math.Sin(angle * System.Math.PI / 4)) * circle.Radius);
             }
             else
             {
@@ -667,9 +465,7 @@ public sealed class PreparedContours
         if (contourOrdinal == PerimeterOrdinal || pinned[contourOrdinal] != null)
             return Array.Empty<ContourChoice>();
         targets = targets.Where(t => t.Owner == this && t.ContourOrdinal == contourOrdinal).Take(max).ToArray();
-        var depth = System.Math.Max(ParametersFor(contourOrdinal).GetEffectivePierceClearance(),
+        var found = ErodedPierce.Find(shape, ParametersFor(contourOrdinal).GetEffectivePierceClearance(),
-            ApplicableLeadInLength(contourOrdinal));
-        var found = ErodedPierce.Find(shape, depth,
             targets.Select(t => t.Point).ToArray(), max);
         var entries = new List<ContourChoice>();
         for (var i = 0; i < found.Pierces.Count; i++)
@@ -714,7 +510,7 @@ public sealed class PreparedContours
     }
 
     /// <summary>
-    /// The uncapped preferred automatic start catalog for one contour, in preference then
+    /// The uncapped preferred automatic start catalogue for one contour, in preference then
     /// contour-travel order: convex corners of the contour's own winding, then straight-edge
     /// midpoints, then tangent line/arc joints. Reflex and cusp vertices, collinear
     /// line/line splits, circles and interior points never appear; each geometric point is
@@ -729,15 +525,13 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return new[] { new ContourEntryCandidate(pin, AutomaticEntryKind.Pinned) };
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return new[] { new ContourEntryCandidate(fixedEntry, AutomaticEntryKind.Pinned) };
         if (IsSingleCircle(shape))
-            throw new ArgumentException("Circles have no preferred corners or joints; use the fallback catalog.");
+            throw new ArgumentException("Circles have no preferred corners or joints; use the fallback catalogue.");
         return SupportFiltered(contourOrdinal, PreferredCandidates(shape, contourOrdinal, token), SupportEntries.Steadying);
     }
 
     /// <summary>
-    /// The complete uncapped automatic start catalog: the preferred points of
+    /// The complete uncapped automatic start catalogue: the preferred points of
     /// <see cref="AutomaticEntryCandidates"/> followed by tier-3 fallbacks — native arc
     /// midpoints, near-convex-corner points on straight edges, the eight compass points of a
     /// whole circle, and the exact target-facing closest point toward
@@ -745,7 +539,7 @@ public sealed class PreparedContours
     /// A pure-circle contour therefore yields compass points instead of refusing. Every
     /// fallback passes the same reflex/cusp exclusion and geometric duplicate merge as the
     /// preferred tier; fallbacks never replace a preferred point at the same geometry. A
-    /// pinned contour's catalog is its pinned entry alone: nothing may relocate it.
+    /// pinned contour's catalogue is its pinned entry alone: nothing may relocate it.
     /// </summary>
     internal IReadOnlyList<ContourEntryCandidate> AutomaticEntryCandidatesWithFallbacks(
         int contourOrdinal,
@@ -757,8 +551,6 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return new[] { new ContourEntryCandidate(pin, AutomaticEntryKind.Pinned) };
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return new[] { new ContourEntryCandidate(fixedEntry, AutomaticEntryKind.Pinned) };
         var all = IsSingleCircle(shape)
             ? new List<ContourEntryCandidate>()
             : PreferredCandidates(shape, contourOrdinal, token);
@@ -768,7 +560,7 @@ public sealed class PreparedContours
 
     /// <summary>
     /// Whether this preparation tabs its perimeter for support (see <see cref="WithSupportTab"/>):
-    /// its automatic catalog then keeps to steadying points unless asked for a fallback.
+    /// its automatic catalogue then keeps to steadying points unless asked for a fallback.
     /// </summary>
     internal bool HasSupportTab => support != null && !IsPinned(PerimeterOrdinal);
 
@@ -809,8 +601,8 @@ public sealed class PreparedContours
 
     /// <summary>Preferred tier: convex corners, straight midpoints, tangent joints.</summary>
     private List<ContourEntryCandidate> PreferredCandidates(Shape shape, int contourOrdinal, CancellationToken token)
-        => CatalogPoints(shape, token)
+        => CataloguePoints(shape, token)
-            .Select(p => new ContourEntryCandidate(Entry(contourOrdinal, p.EntityOrdinal, p.Point), p.Kind, p.CornerReach))
+            .Select(p => new ContourEntryCandidate(Entry(contourOrdinal, p.EntityOrdinal, p.Point), p.Kind))
             .ToList();
 
     /// <summary>
@@ -842,8 +634,8 @@ public sealed class PreparedContours
                     // The legacy eight compass points, same native construction.
                     for (var angle = 0; angle < 8; angle++)
                         fallbacks.Add(Fallback(i, circle.Center + new Vector(
-                            PortableMath.Cos(angle * System.Math.PI / 4),
+                            System.Math.Cos(angle * System.Math.PI / 4),
-                            PortableMath.Sin(angle * System.Math.PI / 4)) * circle.Radius,
+                            System.Math.Sin(angle * System.Math.PI / 4)) * circle.Radius,
                             AutomaticEntryKind.CircleCompass));
                     break;
             }
@@ -855,7 +647,7 @@ public sealed class PreparedContours
         // endpoint and so never lands on the reflex/cusp vertex at the far end.
         if (lead > 0 && !(count == 1 && shape.Entities[0] is Circle))
         {
-            foreach (var corner in CatalogPoints(shape, token)
+            foreach (var corner in CataloguePoints(shape, token)
                          .Where(p => p.Kind == AutomaticEntryKind.ConvexCorner))
             {
                 token.ThrowIfCancellationRequested();
@@ -969,16 +761,14 @@ public sealed class PreparedContours
         };
 
     /// <summary>
-    /// The preferred catalog points for one contour: for each entity, its convex corner
+    /// The preferred catalogue points for one contour: for each entity, its convex corner
     /// (end vertex, classified from the contour's own winding) and its straight-edge midpoint,
-    /// plus tangent line/arc joints. The joints of a corner fillet (see <see cref="FilletReach"/>)
+    /// plus tangent line/arc joints. Reflex, cusp and collinear-split vertices contribute
-    /// are that corner's convex corners. Reflex, cusp and collinear-split vertices contribute
     /// nothing; a single whole circle yields no points at all.
     /// </summary>
-    private List<(int EntityOrdinal, Vector Point, AutomaticEntryKind Kind, double CornerReach)> CatalogPoints(
+    private List<(int EntityOrdinal, Vector Point, AutomaticEntryKind Kind)> CataloguePoints(Shape shape, CancellationToken token)
-        Shape shape, CancellationToken token)
     {
-        var found = new List<(int, Vector, AutomaticEntryKind, double)>();
+        var found = new List<(int, Vector, AutomaticEntryKind)>();
         var count = shape.Entities.Count;
         if (count == 1 && shape.Entities[0] is Circle)
         {
@@ -993,7 +783,7 @@ public sealed class PreparedContours
             token.ThrowIfCancellationRequested();
             var entity = shape.Entities[i];
 
-            // Vertex reached by traveling along entity i (its end point), reported under
+            // Vertex reached by travelling along entity i (its end point), reported under
             // entity i. The closed contour guarantees every vertex appears exactly once
             // this way; each is classified from the contour's own winding.
             var vertex = End(entity);
@@ -1002,65 +792,29 @@ public sealed class PreparedContours
                 switch (corner.Kind)
                 {
                     case ContourCuttingStrategy.CornerKind.Convex:
-                        found.Add((i, vertex, AutomaticEntryKind.ConvexCorner, 0));
+                        found.Add((i, vertex, AutomaticEntryKind.ConvexCorner));
                         break;
                     case ContourCuttingStrategy.CornerKind.Smooth
                         when entity is Line && Next(i) is Arc:
                         // A line leaving into an arc: the tangent joint. The reverse travel
                         // order classifies the same joint from the arc, matched below.
-                        found.Add(Joint(i, vertex, (i + 1) % count));
+                        found.Add((i, vertex, AutomaticEntryKind.TangentJoint));
                         break;
                     // Reflex, cusp, collinear splits (smooth line→line) and arc→line joins
                     // of a plain straight edge are not preferred automatic starts here.
                     case ContourCuttingStrategy.CornerKind.Smooth
                         when entity is Arc && Next(i) is Line:
-                        found.Add(Joint(i, vertex, i));
+                        found.Add((i, vertex, AutomaticEntryKind.TangentJoint));
                         break;
                 }
             }
 
             if (entity is Line line)
-                found.Add((i, line.MidPoint, AutomaticEntryKind.StraightMidpoint, 0));
+                found.Add((i, line.MidPoint, AutomaticEntryKind.StraightMidpoint));
         }
         return found;
 
         Entity Next(int index) => shape.Entities[(index + 1) % count];
-
-        (int, Vector, AutomaticEntryKind, double) Joint(int entityOrdinal, Vector vertex, int arcOrdinal) =>
-            FilletReach(shape, arcOrdinal) is { } reach
-                ? (entityOrdinal, vertex, AutomaticEntryKind.ConvexCorner, reach)
-                : (entityOrdinal, vertex, AutomaticEntryKind.TangentJoint, 0);
-    }
-
-    /// <summary>
-    /// How far the joints of the arc at <paramref name="arcOrdinal"/> lie from the sharp corner it
-    /// rounds, when it is a corner fillet: tangent to straight edges at both ends, turning less
-    /// than a half circle the convex way, and reaching back along each edge no further than the
-    /// edge is long. A fillet's joints start the cut at the corner, where the mismatch when the
-    /// cut closes is least seen, instead of on a straight edge. Null for any other arc.
-    /// </summary>
-    private static double? FilletReach(Shape shape, int arcOrdinal)
-    {
-        var count = shape.Entities.Count;
-        if (shape.Entities[arcOrdinal] is not Arc arc
-            || shape.Entities[(arcOrdinal + count - 1) % count] is not Line before
-            || shape.Entities[(arcOrdinal + 1) % count] is not Line after)
-            return null;
-        var sweep = arc.SweepAngle();
-        if (sweep >= System.Math.PI - OpenNest.Math.Tolerance.Epsilon)
-            return null;
-        if (!IsSmooth(before.EndPoint, before) || !IsSmooth(arc.EndPoint(), arc))
-            return null;
-        var winding = ContourCuttingStrategy.DetermineWinding(shape);
-        if (ContourCuttingStrategy.ClassifyTurn((before.EndPoint - before.StartPoint).Normalize(),
-                (after.EndPoint - after.StartPoint).Normalize(), winding) != ContourCuttingStrategy.CornerKind.Convex)
-            return null;
-        var reach = arc.Radius * PortableMath.Tan(sweep / 2);
-        return reach <= System.Math.Min(before.Length, after.Length) ? reach : null;
-
-        bool IsSmooth(Vector vertex, Entity entity) =>
-            ContourCuttingStrategy.TryClassifyAutomaticStartCorner(shape, vertex, entity, out var corner)
-            && corner.Kind == ContourCuttingStrategy.CornerKind.Smooth;
     }
 
     /// <summary>Emits every contour once in caller order, holes before perimeter, with scribes once.</summary>
@@ -1088,8 +842,8 @@ public sealed class PreparedContours
         // reads only the chosen contour and the contour count, so only that contour is cloned.
         var owned = new Shape[shapes.Length];
         owned[choice.ContourOrdinal] = (Shape)shapes[choice.ContourOrdinal].Clone();
-        return new ContourCuttingStrategy { Parameters = parameters, PierceZones = pierceZones }.EmitCandidateIsolated(
+        return new ContourCuttingStrategy { Parameters = parameters }.EmitCandidateIsolated(
-            owned, scribes.Select(e => e.Clone()).ToList(), choice, contourParameters, PerimeterOrdinal, commonLine);
+            owned, scribes.Select(e => e.Clone()).ToList(), choice, contourParameters, PerimeterOrdinal);
     }
 
     // Each prefix is a standalone owned program, including the same scribes and break cuts once.
@@ -1101,11 +855,11 @@ public sealed class PreparedContours
 
     // Only a complete emission carries a display perimeter's tail: prefixes are search probes.
     private Program EmitOwned(IReadOnlyList<ContourChoice> choices, bool complete) =>
-        new ContourCuttingStrategy { Parameters = parameters, PierceZones = pierceZones }.EmitPrepared(
+        new ContourCuttingStrategy { Parameters = parameters }.EmitPrepared(
             shapes.Select(s => (Shape)s.Clone()).ToArray(), scribes.Select(e => e.Clone()).ToList(), choices,
             contourParameters, breakCuts.Select(s => (Shape)s.Clone()).ToList(),
             tabbedCutouts.Select(s => (Shape)s.Clone()).ToList(), PerimeterOrdinal,
-            complete ? (Shape)displayOutline?.Clone() : null, commonLine, slugSlices);
+            complete ? (Shape)displayOutline?.Clone() : null);
 
     /// <summary>Open break cuts this preparation cuts before its contours.</summary>
     public int BreakCutCount => breakCuts.Count;
@@ -1125,9 +879,8 @@ public sealed class PreparedContours
     {
         token.ThrowIfCancellationRequested();
         var expected = ExecutionMotionReader.ReadSupported(Emit(choices), location, null, token);
-        // Only the outside is tabbed, with its own pin's tab when it is pinned. A common-line
+        // Only the outside is tabbed, with its own pin's tab when it is pinned.
-        // member's shared spans are accounted as the material's tabs, never as a tab gap.
+        if (!hasCutPerimeter)
-        if (!hasCutPerimeter || commonLine != null)
             return new(this, choices, expected, 0);
         var perimeter = ParametersFor(PerimeterOrdinal);
         return new(this, choices, expected, perimeter.TabsEnabled ? perimeter.TabConfig.Size : 0);
@@ -1160,11 +913,6 @@ public sealed class PreparedContours
         // A pinned contour is cut exactly as pinned: no other entry may be emitted for it.
         if (pinned[choice.ContourOrdinal] is { } pin && pin != choice)
             throw new ArgumentException("A pinned contour keeps its drawing pin's entry.");
-        // A common-line perimeter is cut from its one fixed entry.
-        if (commonLineEntry != null && choice.ContourOrdinal == PerimeterOrdinal
-            && (choice.EntityOrdinal != commonLineEntry.EntityOrdinal || choice.Point != commonLineEntry.Point
-                || choice.Pierce != commonLineEntry.Pierce))
-            throw new ArgumentException("A common-line member's perimeter is cut from its fixed entry.");
         if (choice.Pierce is { } pierce)
         {
             PostVerificationGeometry.Validate(pierce);
@@ -1173,27 +921,24 @@ public sealed class PreparedContours
         }
     }
 
-    private ContourChoice FixedCommonLineEntry(int contourOrdinal) =>
-        commonLineEntry != null && contourOrdinal == PerimeterOrdinal ? commonLineEntry : null;
-
     private Shape GetShape(int ordinal) => ordinal < 0 || ordinal >= Count
         ? throw new ArgumentException("Foreign contour ordinal.") : shapes[ordinal];
 
     /// <summary>
-    /// Representative POINTS per contour ordinal (bounding-box center) for hole routing
+    /// Representative POINTS per contour ordinal (bounding-box centre) for hole routing
     /// only — the S10 <c>CuttingHoleOrder</c> proxy. The perimeter has no entry; it is the
     /// route's fixed endpoint, not a stop. These are ordering proxies, never cut points.
     /// </summary>
-    internal IReadOnlyList<Vector?> HoleCenters(CancellationToken token = default)
+    internal IReadOnlyList<Vector?> HoleCentres(CancellationToken token = default)
     {
         token.ThrowIfCancellationRequested();
-        var centers = new Vector?[Count];
+        var centres = new Vector?[Count];
         for (var contour = 0; contour < PerimeterOrdinal; contour++)
         {
             token.ThrowIfCancellationRequested();
-            centers[contour] = GetShape(contour).BoundingBox.Center;
+            centres[contour] = GetShape(contour).BoundingBox.Center;
         }
-        return centers;
+        return centres;
     }
 
     /// <summary>The bounding box of contour <paramref name="contourOrdinal"/>, local. A routing hint only.</summary>
@@ -1215,7 +960,7 @@ public sealed class PreparedContours
     /// which treat a point within <see cref="OpenNest.Math.Tolerance.Epsilon"/> of an endpoint as that endpoint and
     /// start the contour there. An entry that close to a vertex is that vertex, so the lead-in ends
     /// where the contour starts: otherwise the span between them (5e-8 in on imported arcs whose
-    /// stored center sits beside the chord's midpoint) is never cut.
+    /// stored centre sits beside the chord's midpoint) is never cut.
     /// </summary>
     private static Vector SnapToVertex(Shape shape, int entityOrdinal, Vector point)
     {

OpenNest.Core/CNC/CuttingPlanning/ReleasedContourState.cs

@@ -12,12 +12,6 @@ public sealed class ReleasedContourState
 {
     private readonly List<Obstacle> obstacles = new();
     private readonly bool reportMissingLeadIns;
-    // Parts (by caller part number) whose single tab may not hold them level: once cut, their
-    // tabbed perimeter is an obstacle as if cut free, since the part may tip into the head's path.
-    private readonly Func<int, bool> tabMayNotHold;
-    // Common-line members (by caller part number): their outside is cut as open remainder pieces
-    // that end in kerf their shared cuts opened, so once the part's program ends it is cut free.
-    private readonly Func<int, bool> commonLineMember;
     // How the last analysed part ended: the contours it numbered, and whether nothing it left
     // (open fragments, deferred findings, a reported tab, a dangling lead-in) can change how
     // motions appended to it are judged. See Continue.
@@ -28,30 +22,14 @@ public sealed class ReleasedContourState
 
     /// <param name="reportMissingLeadIns">Keep pre-post warnings by default. Planning
     /// may pierce directly on a contour and checks travel without requiring a lead.</param>
-    public ReleasedContourState(bool reportMissingLeadIns) : this(reportMissingLeadIns, null) { }
+    public ReleasedContourState(bool reportMissingLeadIns)
-
-    /// <param name="tabMayNotHold">Part numbers whose support tab may not hold them level (no
-    /// single tab can steady them): the longest open cut a part leaves, its tabbed
-    /// perimeter, becomes an obstacle when the part ends, closed across its tab gap.</param>
-    public ReleasedContourState(bool reportMissingLeadIns, Func<int, bool> tabMayNotHold)
-        : this(reportMissingLeadIns, tabMayNotHold, null)
-    {
-    }
-
-    /// <param name="commonLineMember">Part numbers of common-line members (docs/common-line-cutting.md):
-    /// a member's open cuts are its remainder pieces, which end in kerf its shared cuts opened. They
-    /// need no retention proof, and when the part ends they become one obstacle, closed across its
-    /// shared spans, since the part is then cut free.</param>
-    public ReleasedContourState(bool reportMissingLeadIns, Func<int, bool> tabMayNotHold, Func<int, bool> commonLineMember)
     {
         this.reportMissingLeadIns = reportMissingLeadIns;
-        this.tabMayNotHold = tabMayNotHold;
-        this.commonLineMember = commonLineMember;
     }
 
     public ReleasedContourState Copy()
     {
-        var copy = new ReleasedContourState(reportMissingLeadIns, tabMayNotHold, commonLineMember)
+        var copy = new ReleasedContourState(reportMissingLeadIns)
         {
             partContours = partContours,
             partClosed = partClosed,
@@ -76,11 +54,9 @@ public sealed class ReleasedContourState
     /// As <see cref="Check(OwnedExecution, Vector?, int, bool, CancellationToken)"/>, but a
     /// finding whose offending motion <paramref name="isFixed"/> owns (by motion index) is
     /// returned apart: a fixed emission is accepted as given and only reported. The checker
-    /// state advances exactly as it would without ownership. Crossings made by a rapid with the
+    /// state advances exactly as it would without ownership.
-    /// head raised are returned apart as well, as Raised: they are the raise's reason, not a fault.
     /// </summary>
-    internal (IReadOnlyList<PostVerificationFinding> Strict, IReadOnlyList<PostVerificationFinding> Fixed,
+    internal (IReadOnlyList<PostVerificationFinding> Strict, IReadOnlyList<PostVerificationFinding> Fixed) Check(
-        IReadOnlyList<PostVerificationFinding> Raised) Check(
         OwnedExecution execution, Vector? arrival, int partNumber, bool cutoff, Func<int, bool> isFixed,
         CancellationToken token)
     {
@@ -91,10 +67,8 @@ public sealed class ReleasedContourState
         moves[0] = moves[0].WithStart(arrival);
         var findings = new List<PostVerificationFinding>();
         var fixedFindings = new List<PostVerificationFinding>();
-        var raisedFindings = new List<PostVerificationFinding>();
+        AnalyzeMoves(moves, cutoff, findings, 1, partNumber, token, isFixed, fixedFindings);
-        AnalyzeMoves(moves, cutoff, findings, 1, partNumber, token, isFixed, fixedFindings,
+        return (findings.AsReadOnly(), fixedFindings.AsReadOnly());
-            raisedFindings: raisedFindings);
-        return (findings.AsReadOnly(), fixedFindings.AsReadOnly(), raisedFindings.AsReadOnly());
     }
 
     /// <summary>
@@ -123,7 +97,7 @@ public sealed class ReleasedContourState
     internal void AnalyzeMoves(IReadOnlyList<ExecutionMotion> moves, bool cutoff,
         List<PostVerificationFinding> findings, int plate, int part, CancellationToken token,
         Func<int, bool> isFixed = null, List<PostVerificationFinding> fixedFindings = null,
-        int contoursBefore = 0, List<PostVerificationFinding> raisedFindings = null)
+        bool proveOpenCuts = false, int contoursBefore = 0)
     {
         var current = new CutGroup();
         var unfinished = new List<CutGroup>();
@@ -138,42 +112,29 @@ public sealed class ReleasedContourState
         var hasLead = false;
         var contourNumber = contoursBefore;
         var inBreakCut = false;
-        var member = commonLineMember?.Invoke(part) == true;
         var reportedTab = false;
-        // The contour last closed, and the one a lead-out has just left it into: a cutout's
-        // lead-out ends in its slug, so the rapid after it must leave over that cutout's own cut.
-        CutGroup lastClosed = null;
-        Obstacle lastObstacle = null;
-        Obstacle exited = null;
-        var exitPoint = Vector.Zero;
         for (var index = 0; index < moves.Count; index++)
         {
             token.ThrowIfCancellationRequested();
             var move = moves[index];
             var owned = isFixed?.Invoke(index) == true;
-            if (!move.Rapid && move.Layer != LayerType.Leadout)
+            if (!move.Rapid && move.Layer == LayerType.Break)
-                exited = null;
-            if (!move.Rapid && move.Layer is LayerType.Break or LayerType.CommonLine)
             {
                 // A break cut is intentionally open and retained by its uncut tabs: it is never a
-                // rapid obstacle and never an unexplained fragment, but it is still pierced. A
+                // rapid obstacle and never an unexplained fragment, but it is still pierced.
-                // common line's shared cut runs in the kerf between two parts: it bounds and
-                // retains nothing, so it is never an obstacle and takes no part in the open-cut proof.
                 if (!inBreakCut)
                 {
                     Finish();
                     if (reportMissingLeadIns && !cutoff && !hasLead)
                         Add(new(PostVerificationKind.MissingLeadIn, plate, part, null,
-                            move.Layer == LayerType.Break ? "A break cut is missing lead-in geometry."
+                            "A break cut is missing lead-in geometry.")
-                                : "A common-line shared cut is missing lead-in geometry.")
                         { Location = move.Curve.Start }, owned);
                     inBreakCut = true;
                     hasLead = false;
                     previous = new CutGroup();
                     previous.Leads.AddRange(leadIns);
                     leadIns.Clear();
-                    if (move.Layer == LayerType.Break)
+                    otherOpen.Add(previous);
-                        otherOpen.Add(previous);
                 }
                 if (move.Curve.Length > PostVerificationGeometry.Epsilon)
                     previous.Curves.Add(move.Curve);
@@ -187,15 +148,8 @@ public sealed class ReleasedContourState
                 loose.Leads.AddRange(leadIns);
                 leadIns.Clear();
                 previous = null;
-                var leaving = exited;
-                exited = null;
                 if (move.Start is not { } start || start.DistanceTo(move.End) <= PostVerificationGeometry.Epsilon)
                     continue;
-                // A raised rapid out of a slug its cutout's lead-out ended in is the designed way
-                // out: it may cross that cutout once, and passes over the rest with the head up.
-                if (move.HeadRaised && leaving != null && start.DistanceTo(exitPoint) <= PostVerificationGeometry.Epsilon
-                    && LeavesOnce(leaving, start, move.End, token))
-                    continue;
                 var reach = new PostVerificationGeometry.Extent(System.Math.Min(start.X, move.End.X),
                     System.Math.Min(start.Y, move.End.Y), System.Math.Max(start.X, move.End.X),
                     System.Math.Max(start.Y, move.End.Y));
@@ -212,24 +166,16 @@ public sealed class ReleasedContourState
                     if (obstacle.OvercutEnd is { } tailEnd && tailEnd.DistanceTo(start) <= PostVerificationGeometry.Epsilon
                         && start.DistanceTo(move.End) > PostVerificationGeometry.RaySeamTolerance)
                         from = start + (move.End - start) * (PostVerificationGeometry.RaySeamTolerance / start.DistanceTo(move.End));
-                    if (!PostVerificationGeometry.Crosses(from, move.End, obstacle.Curves, token))
+                    if (PostVerificationGeometry.Crosses(from, move.End, obstacle.Curves, token))
-                        continue;
+                        Add(new(PostVerificationKind.RapidCrossing, plate, part, obstacle.Part,
-                    var crossing = new PostVerificationFinding(PostVerificationKind.RapidCrossing, plate, part,
+                            $"Direct XY rapid crosses or touches completed untabbed contour {obstacle.Contour} " +
-                        obstacle.Part, (move.HeadRaised ? "Head-raised" : "Direct") + " XY rapid crosses or touches "
+                            $"of part {obstacle.Part}.")
-                        + (obstacle.TabMayNotHold
+                        {
-                            ? $"the tabbed outside of part {obstacle.Part}, which its tab may not hold level."
+                            Location = (start + move.End) * 0.5,
-                            : $"completed untabbed contour {obstacle.Contour} of part {obstacle.Part}."))
+                            RapidStart = start,
-                    {
+                            RapidEnd = move.End,
-                        Location = (start + move.End) * 0.5,
+                            ContactPoints = PostVerificationGeometry.ContactPoints(from, move.End, obstacle.Curves, token)
-                        RapidStart = start,
+                        }, owned);
-                        RapidEnd = move.End,
-                        ContactPoints = PostVerificationGeometry.ContactPoints(from, move.End, obstacle.Curves, token)
-                    };
-                    // The head clears a cut part on a raised rapid; the crossing is the raise's reason.
-                    if (move.HeadRaised)
-                        raisedFindings?.Add(crossing);
-                    else
-                        Add(crossing, owned);
                 }
             }
             else if (move.Layer == LayerType.Leadin)
@@ -250,11 +196,6 @@ public sealed class ReleasedContourState
                             "A lead-out follows an open cutting contour and may cut through its retention gap. " +
                             "Rapid safety for that contour requires manual review."), owned);
                     (previous ?? loose).Leads.Add(move.Curve);
-                    if (previous != null && ReferenceEquals(previous, lastClosed))
-                    {
-                        exited = lastObstacle;
-                        exitPoint = move.Curve.End;
-                    }
                 }
                 Finish();
                 hasLead = false;
@@ -310,20 +251,14 @@ public sealed class ReleasedContourState
         Finish();
         loose.Leads.AddRange(leadIns);
         // Open cuts that provably enclose nothing retain all their material, however many
-        // pieces a tabbed cutout was cut in, and so does a tabbed perimeter whose lead-out stays
+        // pieces a tabbed cutout was cut in. Otherwise they need manual review. Planning proves
-        // out of its tab: planning and pre-post review prove them alike. Otherwise they need
+        // them too (its own tabbed cutouts are cut in pieces without lead-outs), but only
-        // manual review.
+        // pre-post review lets the proof clear a lead-out: planning keeps refusing to certify
-        // A common-line member's open cuts are its remainder pieces: they end in shared kerf, not at
+        // its own tabs followed by a lead-out.
-        // tabs, and the planner's contour accounting proves they cut its outside exactly once.
-        var remainders = member && !cutoff && unfinished.Count > 0;
-        // Slug slices (docs/support-tabs.md#slug-slices) cross one another inside one of the part's
-        // own holes: what they enclose is that hole's slug, scrap, so they take no part in the proof.
         var retained = !cutoff && (unfinished.Count > 1 || deferred.Count > 0)
-            && (remainders || unfinished.All(LeadsClearOpenEnds)
+            && unfinished.All(LeadsClearOpenEnds)
-                && OpenCutsEncloseNothing(closed, unfinished
+            && OpenCutsEncloseNothing(closed, unfinished.Concat(otherOpen).Append(loose).ToList(), token);
-                    .Concat(otherOpen.Where(group => !CutsOnlySlug(group, closed, unfinished, token)))
+        for (var i = deferred.Count - 1; i >= 0 && !(retained && proveOpenCuts); i--)
-                    .Append(loose).ToList(), token));
-        for (var i = deferred.Count - 1; i >= 0 && !retained; i--)
             deferred[i].Target.Insert(deferred[i].Index, deferred[i].Finding);
         // Only one open fragment per part can be the planner's own certified tab, so a
         // further fragment that a fixed emission cut makes this uncertainty that emission's.
@@ -332,31 +267,6 @@ public sealed class ReleasedContourState
                 "Multiple interrupted/open cutting fragments remain. Their combined cuts may release material; " +
                 "they cannot be assumed to be retained by tabs. Review rapid travel manually."),
                 unfinished.Any(chain => chain.Fixed));
-        // A part that may tip once cut is avoided like one cut free. The retention proof above is
-        // unchanged: the part is still attached by its tab, just not held level by it.
-        if (remainders)
-        {
-            // Its remainder pieces in cutting order, joined across the shared spans between them:
-            // the member's outside, now cut free.
-            var curves = new List<PostVerificationGeometry.Curve>();
-            foreach (var chain in unfinished)
-            {
-                if (curves.Count > 0 && curves[^1].End.DistanceTo(chain.Curves[0].Start) > PostVerificationGeometry.Epsilon)
-                    curves.Add(PostVerificationGeometry.Curve.Create(curves[^1].End, chain.Curves[0].Start, null, false));
-                curves.AddRange(chain.Curves);
-            }
-            if (curves[^1].End.DistanceTo(curves[0].Start) > PostVerificationGeometry.Epsilon)
-                curves.Add(PostVerificationGeometry.Curve.Create(curves[^1].End, curves[0].Start, null, false));
-            obstacles.Add(new(part, contourNumber, curves, null));
-        }
-        else if (!cutoff && unfinished.Count > 0 && tabMayNotHold?.Invoke(part) == true)
-        {
-            var perimeter = unfinished.MaxBy(chain => chain.Curves.Sum(curve => curve.Length));
-            var curves = perimeter.Curves.ToList();
-            if (curves[^1].End.DistanceTo(curves[0].Start) > PostVerificationGeometry.Epsilon)
-                curves.Add(PostVerificationGeometry.Curve.Create(curves[^1].End, curves[0].Start, null, false));
-            obstacles.Add(new(part, contourNumber, curves, null) { TabMayNotHold = true });
-        }
         partContours = contourNumber;
         partClosed = !cutoff && isFixed == null && unfinished.Count == 0 && deferred.Count == 0 && !reportedTab
             && !inBreakCut && loose.Leads.Count == 0;
@@ -384,10 +294,8 @@ public sealed class ReleasedContourState
             // no flag or tab configuration is used as evidence of retention.
             if (!cutoff && (current.OvercutEnd.HasValue || PostVerificationGeometry.Closed(current.Curves)))
             {
-                lastObstacle = new(part, contourNumber, current.Curves.ToArray(), current.OvercutEnd);
+                obstacles.Add(new(part, contourNumber, current.Curves.ToArray(), current.OvercutEnd));
-                obstacles.Add(lastObstacle);
                 closed.Add(current);
-                lastClosed = current;
             }
             else if (!cutoff)
                 unfinished.Add(current);
@@ -395,16 +303,6 @@ public sealed class ReleasedContourState
         }
     }
 
-    /// <summary>
-    /// Whether the rapid from <paramref name="start"/> inside <paramref name="cutout"/> to
-    /// <paramref name="end"/> outside it meets its cut just once, on the way out: a rapid that
-    /// leaves a re-entrant cutout and passes back over it crosses the cut where the slug may lie.
-    /// </summary>
-    private static bool LeavesOnce(Obstacle cutout, Vector start, Vector end, CancellationToken token) =>
-        PostVerificationGeometry.Inside(start, cutout.Curves, token)
-        && !PostVerificationGeometry.Inside(end, cutout.Curves, token)
-        && PostVerificationGeometry.ContactPoints(start, end, cutout.Curves, token).Count == 1;
-
     /// <summary>
     /// The closing piece of a contour cut on past its own start along its first cut, as a source
     /// CAM's seam overcut is (see <see cref="SeamOvercut"/> for the clean-contour form): the last
@@ -435,7 +333,7 @@ public sealed class ReleasedContourState
     /// contour with its own leads already encloses whatever it releases and counts as one node.
     /// Open cuts may touch any cut only at their own ends, and must form no loop through those
     /// nodes or each other: a forest of open paths separates no region of the sheet. Kerf and
-    /// tab strength are not modeled, exactly as for a single open contour.
+    /// tab strength are not modelled, exactly as for a single open contour.
     /// </summary>
     private const double JointTolerance = 1e-5;
 
@@ -465,35 +363,6 @@ public sealed class ReleasedContourState
             || lead.End.DistanceTo(point) <= PostVerificationGeometry.Epsilon;
     }
 
-    /// <summary>
-    /// Whether break cut <paramref name="group"/>, its leads included, lies wholly inside one of
-    /// the part's closed holes and touches none of it: whatever it frees is that hole's slug. Only
-    /// straight cuts qualify. The part's outside is its largest cut, never a hole.
-    /// </summary>
-    private static bool CutsOnlySlug(CutGroup group, IReadOnlyList<CutGroup> closed, IReadOnlyList<CutGroup> unfinished,
-        CancellationToken token)
-    {
-        var cuts = group.Curves.Concat(group.Leads).ToList();
-        if (cuts.Count == 0 || !cuts.TrueForAll(cut => cut.IsLine))
-            return false;
-        var outside = closed.Concat(unfinished).Where(cut => cut.Curves.Count > 0).MaxBy(cut =>
-        {
-            var extent = cut.Curves.Aggregate(PostVerificationGeometry.Extent.None, (sum, curve) => sum.Union(curve.Extent));
-            return (extent.MaxX - extent.MinX) * (extent.MaxY - extent.MinY);
-        });
-        foreach (var hole in closed)
-        {
-            token.ThrowIfCancellationRequested();
-            if (ReferenceEquals(hole, outside) || !PostVerificationGeometry.Closed(hole.Curves))
-                continue;
-            if (cuts.TrueForAll(cut => PostVerificationGeometry.Inside(cut.Start, hole.Curves, token)
-                && PostVerificationGeometry.Inside(cut.End, hole.Curves, token)
-                && PostVerificationGeometry.ContactPoints(cut.Start, cut.End, hole.Curves, token).Count == 0))
-                return true;
-        }
-        return false;
-    }
-
     private static bool OpenCutsEncloseNothing(IReadOnlyList<CutGroup> closed, IReadOnlyList<CutGroup> open,
         CancellationToken token)
     {
@@ -624,8 +493,5 @@ public sealed class ReleasedContourState
     {
         internal PostVerificationGeometry.Extent Extent { get; } =
             Curves.Aggregate(PostVerificationGeometry.Extent.None, (extent, curve) => extent.Union(curve.Extent));
-
-        /// <summary>A tabbed perimeter closed across its tab gap, for a part its tab may not hold level.</summary>
-        internal bool TabMayNotHold { get; init; }
     }
 }

OpenNest.Core/CNC/CuttingPlanning/SeamOvercut.cs

@@ -160,11 +160,11 @@ internal static class SeamOvercut
         return true;
     }
 
-    /// <summary>The angle traveled around <paramref name="center"/> from one point to another, in [0, 2pi).</summary>
+    /// <summary>The angle travelled around <paramref name="center"/> from one point to another, in [0, 2pi).</summary>
     private static double Travel(Vector center, Vector from, Vector to, bool clockwise)
     {
-        var start = PortableMath.Atan2(from.Y - center.Y, from.X - center.X);
+        var start = System.Math.Atan2(from.Y - center.Y, from.X - center.X);
-        var end = PortableMath.Atan2(to.Y - center.Y, to.X - center.X);
+        var end = System.Math.Atan2(to.Y - center.Y, to.X - center.X);
         var travel = (clockwise ? start - end : end - start) % (2 * System.Math.PI);
         return travel < 0 ? travel + 2 * System.Math.PI : travel;
     }

OpenNest.Core/CNC/CuttingPlanning/StateFingerprint.cs

@@ -90,13 +90,9 @@ internal static class StateFingerprint
             TabSettings(p.TabConfig);
             Flag(p.TabsEnabled);
             Flag(p.SupportTabs);
-            Flag(p.TabBySize);
+            Number(p.NoBedTabMinWidth);
-            Number(p.TabSizeMinWidth);
+            Number(p.NoBedTabMaxWidth);
-            Number(p.TabSizeMaxWidth);
             Number(p.TabHeldMaxLength);
-            // Only when on, so fingerprints taken before the setting existed still match.
-            if (p.SliceTippingSlugs)
-                text.Append("slugSlices;");
             Sequence(p.Sequencing);
             Assignment(p.Assignment);
             text.Append('}');

OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs

@@ -10,12 +10,6 @@ namespace OpenNest.CNC.CuttingStrategy
     {
         public CuttingParameters Parameters { get; set; }
 
-        /// <summary>
-        /// Remembers pierce-zone resolutions by contour ordinal across the emissions of one
-        /// preparation (see <see cref="PierceZoneMemo"/>); null resolves every emission afresh.
-        /// </summary>
-        internal PierceZoneMemo PierceZones { get; set; }
-
         private record ContourEntry(Shape Shape, Vector Point, Entity Entity);
 
         public CuttingResult Apply(Program partProgram, Vector approachPoint)
@@ -267,17 +261,14 @@ namespace OpenNest.CNC.CuttingStrategy
         internal Program EmitPrepared(Shape[] shapes, List<Entity> scribes,
             IReadOnlyList<CuttingPlanning.ContourChoice> choices,
             IReadOnlyList<CuttingParameters> contourParameters = null, IReadOnlyList<Shape> breakCuts = null,
-            IReadOnlyList<Shape> tabbedCutouts = null, int? perimeterOrdinal = null, Shape displayTail = null,
+            IReadOnlyList<Shape> tabbedCutouts = null, int? perimeterOrdinal = null, Shape displayTail = null)
-            CuttingPlanning.CommonLinePerimeter commonLine = null, IReadOnlyList<Support.SlugSlice> slugSlices = null)
         {
             var result = new Program(Mode.Absolute);
             EmitScribeContours(result, scribes);
             EmitBreakCuts(result, breakCuts, shapes);
-            EmitSlugSlices(result, slugSlices);
             foreach (var cutout in tabbedCutouts ?? Array.Empty<Shape>())
                 EmitTabbedCutout(result, cutout);
-            EmitChosenContours(result, shapes, choices, contourParameters, perimeterOrdinal ?? shapes.Length - 1,
+            EmitChosenContours(result, shapes, choices, contourParameters, perimeterOrdinal ?? shapes.Length - 1);
-                commonLine);
             if (displayTail != null)
             {
                 // Display only, after every cut: executed reads and posts stop at its marker.
@@ -295,12 +286,11 @@ namespace OpenNest.CNC.CuttingStrategy
         // installed on a Part or accepted as a complete plan.
         internal Program EmitCandidateIsolated(Shape[] shapes, List<Entity> scribes,
             CuttingPlanning.ContourChoice choice, IReadOnlyList<CuttingParameters> contourParameters = null,
-            int? perimeterOrdinal = null, CuttingPlanning.CommonLinePerimeter commonLine = null)
+            int? perimeterOrdinal = null)
         {
             var result = new Program(Mode.Absolute);
             EmitScribeContours(result, scribes);
-            EmitChosenContours(result, shapes, new[] { choice }, contourParameters, perimeterOrdinal ?? shapes.Length - 1,
+            EmitChosenContours(result, shapes, new[] { choice }, contourParameters, perimeterOrdinal ?? shapes.Length - 1);
-                commonLine);
             result.Mode = Mode.Incremental;
             return result;
         }
@@ -311,61 +301,20 @@ namespace OpenNest.CNC.CuttingStrategy
         // prior choices — the differential tests in ContourCandidateEmissionTests pin this.
         private void EmitChosenContours(Program result, Shape[] shapes,
             IReadOnlyList<CuttingPlanning.ContourChoice> choices, IReadOnlyList<CuttingParameters> contourParameters,
-            int perimeterOrdinal, CuttingPlanning.CommonLinePerimeter commonLine = null)
+            int perimeterOrdinal)
         {
             var shared = Parameters;
             try
             {
-                var inSlug = false;
                 foreach (var choice in choices)
                 {
-                    if (commonLine is { StartsOnCommonLine: true } && choice.ContourOrdinal == perimeterOrdinal
-                        && !IsTabbedCutout(shapes[perimeterOrdinal]))
-                    {
-                        // Cut whole from its common line: the straight lead-in from the choice's
-                        // pierce runs along the shared edge, and the perimeter ends where it began,
-                        // beside its partner, so it has no lead-out and no tab.
-                        var whole = CuttingPlanning.OwnedCuttingParameters.Copy(shared);
-                        whole.ExternalLeadOut = new NoLeadOut();
-                        whole.TabsEnabled = false;
-                        Parameters = whole;
-                        var start = result.Codes.Count;
-                        EmitContour(result, shapes[perimeterOrdinal], choice.Point,
-                            shapes[perimeterOrdinal].Entities[choice.EntityOrdinal], ContourType.External,
-                            exactCirclePrograms: true, scrapPierce: choice.Pierce, stopAtCenterLine: false,
-                            memoContour: choice.ContourOrdinal);
-                        if (inSlug && start < result.Codes.Count && result.Codes[start] is RapidMove)
-                            result.Codes.Insert(start, new Comment(HeadRaise.Marker));
-                        inSlug = false;
-                        continue;
-                    }
-                    if (commonLine != null && choice.ContourOrdinal == perimeterOrdinal)
-                    {
-                        // The rapid out of a cutout's slug before it is still made head up.
-                        Parameters = shared;
-                        var first = result.Codes.Count;
-                        EmitCommonLinePerimeter(result, shapes[perimeterOrdinal], commonLine);
-                        if (inSlug && first < result.Codes.Count && result.Codes[first] is RapidMove)
-                            result.Codes.Insert(first, new Comment(HeadRaise.Marker));
-                        inSlug = false;
-                        continue;
-                    }
                     // A contour's own settings apply to its emission alone; scribes and every
                     // other contour keep the shared settings.
                     Parameters = contourParameters?[choice.ContourOrdinal] ?? shared;
                     var shape = shapes[choice.ContourOrdinal];
-                    var arrival = result.Codes.Count;
+                    EmitContour(result, shape, choice.Point, shape.Entities[choice.EntityOrdinal],
-                    var leftInSlug = EmitContour(result, shape, choice.Point, shape.Entities[choice.EntityOrdinal],
                         choice.ContourOrdinal == perimeterOrdinal ? ContourType.External : null,
-                        exactCirclePrograms: true, scrapPierce: choice.Pierce,
+                        exactCirclePrograms: true, scrapPierce: choice.Pierce);
-                        stopAtCenterLine: contourParameters?[choice.ContourOrdinal] == null,
-                        memoContour: choice.ContourOrdinal);
-                    // A cutout's lead-out ends in its slug, which may drop or tip once cut free, so
-                    // the rapid out over the cut is made head up. An overcut or no lead-out leaves
-                    // from the cut itself and stays head down.
-                    if (inSlug && arrival < result.Codes.Count && result.Codes[arrival] is RapidMove or SubProgramCall)
-                        result.Codes.Insert(arrival, new Comment(HeadRaise.Marker));
-                    inSlug = leftInSlug;
                 }
             }
             finally
@@ -484,17 +433,14 @@ namespace OpenNest.CNC.CuttingStrategy
         private static bool SameVector(Vector a, Vector b) => SameBits(a.X, b.X) && SameBits(a.Y, b.Y);
         private static bool SameBits(double a, double b) => BitConverter.DoubleToInt64Bits(a) == BitConverter.DoubleToInt64Bits(b);
 
-        /// <returns>Whether the contour is a cutout left by a lead-out, which ends in its slug.</returns>
+        private void EmitContour(
-        private bool EmitContour(
             Program program,
             Shape shape,
             Vector point,
             Entity entity,
             ContourType? forceType = null,
             bool exactCirclePrograms = false,
-            Vector? scrapPierce = null,
+            Vector? scrapPierce = null
-            bool stopAtCenterLine = false,
-            int? memoContour = null
         )
         {
             var contourType = forceType ?? DetectContourType(shape);
@@ -517,8 +463,8 @@ namespace OpenNest.CNC.CuttingStrategy
 
                     var outwardAngle = normal - System.Math.PI;
                     point = new Vector(
-                        circle.Center.X + circle.Radius * PortableMath.Cos(outwardAngle),
+                        circle.Center.X + circle.Radius * System.Math.Cos(outwardAngle),
-                        circle.Center.Y + circle.Radius * PortableMath.Sin(outwardAngle)
+                        circle.Center.Y + circle.Radius * System.Math.Sin(outwardAngle)
                     );
                 }
 
@@ -526,11 +472,9 @@ namespace OpenNest.CNC.CuttingStrategy
                     leadIn = StraightLeadIn(point, holePierce, out normal);
                 else
                 {
-                    if (stopAtCenterLine)
-                        leadIn = StopAtCenterLine(shape, point, leadIn, normal, winding);
                     leadIn = ClampLeadInForCircle(leadIn, circle, point, normal,
                         Parameters.GetEffectivePierceClearance());
-                    leadIn = PierceZone(memoContour, shape, point, leadIn, normal, winding);
+                    leadIn = ResolvePierceZone(shape, point, leadIn, normal, Parameters.GetPierceZoneRadius(), winding);
                 }
 
                 // Build hole sub-program relative to (0,0)
@@ -548,8 +492,7 @@ namespace OpenNest.CNC.CuttingStrategy
                 var reindexed = relativeShape.ReindexAt(relativePoint, relativeCircle);
 
                 subPgm.Codes.AddRange(ConvertShapeToMoves(reindexed, relativePoint));
-                var holeLeadOut = leadOut.Generate(relativePoint, normal, winding);
+                subPgm.Codes.AddRange(leadOut.Generate(relativePoint, normal, winding));
-                subPgm.Codes.AddRange(holeLeadOut);
                 subPgm.Mode = Mode.Incremental;
 
                 // Deduplicate: check if an identical sub-program already exists
@@ -568,12 +511,11 @@ namespace OpenNest.CNC.CuttingStrategy
                     }
                 );
 
-                return holeLeadOut.Count > 0;
+                return;
             }
 
             var turn = LeadTurn(contourType, winding);
             double leadInNormal;
-            var configuredLeadIn = leadIn;
             // A planner-placed scrap pierce replaces the configured lead-in with a straight one.
             if (scrapPierce is { } pierce)
                 leadIn = StraightLeadIn(point, pierce, out leadInNormal);
@@ -582,12 +524,9 @@ namespace OpenNest.CNC.CuttingStrategy
                 leadIn = ResolveLeadIn(shape, point, entity, contourType, leadIn, winding,
                     Parameters.GetEffectivePierceClearance(), out leadInNormal);
                 if (contourType == ContourType.Internal)
-                {
+                    leadIn = ResolvePierceZone(shape, point, leadIn, leadInNormal, Parameters.GetPierceZoneRadius(), turn);
-                    if (stopAtCenterLine)
-                        leadIn = StopAtCenterLine(shape, point, leadIn, leadInNormal, turn);
-                    leadIn = PierceZone(memoContour, shape, point, leadIn, leadInNormal, turn);
-                }
             }
+            program.Codes.AddRange(leadIn.Generate(point, leadInNormal, turn));
 
             var reindexedShape = shape.ReindexAt(point, entity);
 
@@ -600,7 +539,6 @@ namespace OpenNest.CNC.CuttingStrategy
             var leadOutNormal = normal;
             if (tabbed)
             {
-                var first = reindexedShape.Entities.Count > 0 ? reindexedShape.Entities[0] : null;
                 reindexedShape = TrimShapeForTab(reindexedShape, point, Parameters.TabConfig.Size);
 
                 // Leave from where the trimmed cut actually ends, on that entity's normal:
@@ -610,18 +548,6 @@ namespace OpenNest.CNC.CuttingStrategy
                     var last = reindexedShape.Entities[^1];
                     leadOutPoint = EntityEndPoint(last);
                     leadOutNormal = ComputeNormal(leadOutPoint, last, contourType, winding);
-
-                    // Straight leads either side of a tab that wraps a corner share its bisector,
-                    // as they share the edge normal on a straight edge.
-                    if (ReferenceEquals(leadIn, configuredLeadIn) && leadIn is LineLeadIn lineIn
-                        && leadOut is LineLeadOut lineOut && first is Line or Arc
-                        && TabCornerNormal(shape, point, TravelTangent(first, point), leadInNormal, lineIn,
-                            leadOutPoint, TravelTangent(last, leadOutPoint), leadOutNormal, lineOut, winding,
-                            turn, Parameters.GetEffectivePierceClearance()) is { } tabNormal)
-                    {
-                        leadInNormal = tabNormal;
-                        leadOutNormal = tabNormal;
-                    }
                 }
             }
             else
@@ -630,11 +556,8 @@ namespace OpenNest.CNC.CuttingStrategy
                     Parameters.GetEffectivePierceClearance(), out leadOutNormal);
             }
 
-            program.Codes.AddRange(leadIn.Generate(point, leadInNormal, turn));
             program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
-            var leadOutCodes = leadOut.Generate(leadOutPoint, leadOutNormal, turn);
+            program.Codes.AddRange(leadOut.Generate(leadOutPoint, leadOutNormal, turn));
-            program.Codes.AddRange(leadOutCodes);
-            return contourType != ContourType.External && leadOutCodes.Count > 0;
         }
 
         /// <summary>
@@ -944,18 +867,10 @@ namespace OpenNest.CNC.CuttingStrategy
         /// A turn whose offset over the tangent is within chaining tolerance is smooth,
         /// not a corner.
         /// </summary>
-        private static CornerKind ClassifyCorner(ContourCorner corner, RotationType winding) =>
+        private static CornerKind ClassifyCorner(ContourCorner corner, RotationType winding)
-            ClassifyTurn(corner.TangentIn, corner.TangentOut, winding);
-
-        /// <summary>
-        /// The corner a contour of <paramref name="winding"/> would make turning from travel
-        /// direction <paramref name="tangentIn"/> to <paramref name="tangentOut"/>, classified
-        /// exactly as a shared vertex is (see <see cref="TryClassifyAutomaticStartCorner"/>).
-        /// </summary>
-        internal static CornerKind ClassifyTurn(Vector tangentIn, Vector tangentOut, RotationType winding)
         {
-            var cross = tangentIn.X * tangentOut.Y - tangentIn.Y * tangentOut.X;
+            var cross = corner.TangentIn.X * corner.TangentOut.Y - corner.TangentIn.Y * corner.TangentOut.X;
-            var dot = tangentIn.DotProduct(tangentOut);
+            var dot = corner.TangentIn.DotProduct(corner.TangentOut);
             var turn = winding == RotationType.CCW ? cross : -cross;
 
             if (System.Math.Abs(turn) <= Tolerance.Epsilon)
@@ -975,53 +890,13 @@ namespace OpenNest.CNC.CuttingStrategy
             var adjacentNormal = ComputeNormal(point, corner.Incoming, contourType, winding);
             // Sum unit normals rather than averaging angles (which fails at 0/2Ï€).
             // Winding makes this point into the scrap even at reflex corners.
-            var x = PortableMath.Cos(normal) + PortableMath.Cos(adjacentNormal);
+            var x = System.Math.Cos(normal) + System.Math.Cos(adjacentNormal);
-            var y = PortableMath.Sin(normal) + PortableMath.Sin(adjacentNormal);
+            var y = System.Math.Sin(normal) + System.Math.Sin(adjacentNormal);
             if (!double.IsFinite(x) || !double.IsFinite(y)
                 || x * x + y * y <= Tolerance.Epsilon * Tolerance.Epsilon)
                 return null; // Opposing normals at a cusp have no unique bisector.
 
-            return Angle.NormalizeRad(PortableMath.Atan2(y, x));
+            return Angle.NormalizeRad(System.Math.Atan2(y, x));
-        }
-
-        /// <summary>
-        /// The normal straight leads either side of a perimeter tab share when the tab wraps a
-        /// convex corner: the bisector of the normals where the cut starts and where it stops, so
-        /// the leads form the V they form on a straight edge, centered on the corner. Null when the
-        /// tab lies on one edge or wraps a reflex turn, or when either lead would not keep
-        /// <paramref name="clearance"/> from the part or would cross it.
-        /// </summary>
-        private static double? TabCornerNormal(
-            Shape shape,
-            Vector start,
-            Vector tangentStart,
-            double startNormal,
-            LineLeadIn leadIn,
-            Vector end,
-            Vector tangentEnd,
-            double endNormal,
-            LineLeadOut leadOut,
-            RotationType winding,
-            RotationType turn,
-            double clearance
-        )
-        {
-            if (!IsFinite(tangentStart) || !IsFinite(tangentEnd)
-                || ClassifyTurn(tangentEnd, tangentStart, winding) != CornerKind.Convex)
-                return null;
-
-            var x = PortableMath.Cos(startNormal) + PortableMath.Cos(endNormal);
-            var y = PortableMath.Sin(startNormal) + PortableMath.Sin(endNormal);
-            if (x * x + y * y <= Tolerance.Epsilon * Tolerance.Epsilon)
-                return null;
-
-            var normal = Angle.NormalizeRad(PortableMath.Atan2(y, x));
-            var pierce = leadIn.GetPiercePoint(start, normal, turn);
-            var leadOutEnd = ((LinearMove)leadOut.Generate(end, normal, turn)[0]).EndPoint;
-            return IsClearStraightLead(shape, start, pierce, clearance)
-                && IsClearStraightLead(shape, end, leadOutEnd, clearance)
-                ? normal
-                : null;
         }
 
         /// <summary>
@@ -1175,28 +1050,16 @@ namespace OpenNest.CNC.CuttingStrategy
         /// <summary>
         /// Keeps a hole's lead-in pierce <paramref name="pierceRadius"/> clear of the hole wall.
         /// A lead-in whose pierce already keeps it, or that pierces on the contour itself, is
-        /// returned as given. Otherwise the pierce moves straight in from the wall to the hole's
+        /// returned as given. Otherwise the pierce moves onto the line from
-        /// center line, or the lead's own length in when that comes first (see
+        /// <paramref name="point"/> toward the hole's pole of inaccessibility (the centre of a
-        /// <see cref="StopAtCenterLine"/>). A lead that cannot keep the zone there moves onto the
+        /// round hole), as close to the contour as the zone allows, and the lead becomes a
-        /// line from <paramref name="point"/> toward the nearest point that keeps it (see
+        /// straight line from there, generated with <paramref name="normal"/>. A hole too small
-        /// <see cref="ErodedPierce"/>) or else the hole's pole of inaccessibility (the center of a
-        /// round hole), as close to the contour as the zone allows. Either way the lead becomes
-        /// a straight line from there, generated with <paramref name="normal"/>. A hole too small
         /// for the zone is pierced at the pole itself, its best clearance; the lead validator and
         /// pre-post review still report the shortfall. Reads only the hole's own geometry, so it
         /// knows nothing of parts nested inside the hole. Shared by program generation and the
         /// manual placement preview. <paramref name="turn"/> is the hole's
         /// <see cref="LeadTurn"/>, which places a curved lead's pierce.
         /// </summary>
-        // The memoized resolution for a contour the preparation emits by ordinal.
-        private LeadIn PierceZone(int? contour, Shape hole, Vector point, LeadIn leadIn, double normal, RotationType turn)
-        {
-            var radius = Parameters.GetPierceZoneRadius();
-            return PierceZones != null && contour is { } ordinal
-                ? PierceZones.Resolve(ordinal, hole, point, leadIn, normal, radius, turn)
-                : ResolvePierceZone(hole, point, leadIn, normal, radius, turn);
-        }
-
         public static LeadIn ResolvePierceZone(Shape hole, Vector point, LeadIn leadIn, double normal,
             double pierceRadius, RotationType turn)
         {
@@ -1208,48 +1071,35 @@ namespace OpenNest.CNC.CuttingStrategy
             var polygon = circle == null
                 ? hole.ToPolygonWithTolerance(System.Math.Max(pierceRadius / 100, Math.Tolerance.ChainTolerance))
                 : null;
-            var configured = leadIn.GetPiercePoint(point, normal, turn);
+            if (Clear(leadIn.GetPiercePoint(point, normal, turn)))
-            if (Clear(configured))
                 return leadIn;
 
-            var depth = CenterLineDepth(hole, point, normal, configured.DistanceTo(point));
-            if (depth > Math.Tolerance.Epsilon && Clear(point + Inward(normal) * depth))
-                return new LineLeadIn { Length = depth, ApproachAngle = 90 };
-
             var pole = circle?.Center ?? PolyLabel.Find(polygon, null,
                 System.Math.Max(pierceRadius / 100, Math.Tolerance.ChainTolerance), PoleSearchCells);
             if (!Inside(pole))
                 return leadIn;
 
-            // The pole of a letter can be a stroke away: head for the stroke beside the entry, on
+            // Clearance grows monotonically toward the pole of a convex hole, so the bisection
-            // its center line when the lead reaches that far.
-            var reach = configured.DistanceTo(point);
-            var toward = pole;
-            if (circle == null && ErodedPierce.Find(hole, System.Math.Max(pierceRadius, reach), new[] { point }, 1)
-                .Pierces is [var eroded] && Clear(eroded))
-                toward = eroded;
-
-            // Clearance grows monotonically along this line in a convex hole, so the bisection
             // finds the shortest clear lead; in other holes it still ends on a clear point.
-            var pierce = toward;
+            var pierce = pole;
-            if (Clear(toward) && (reach < pierceRadius || toward == pole))
+            if (Clear(pole))
             {
                 double low = 0, high = 1;
                 for (var i = 0; i < 40; i++)
                 {
                     var middle = (low + high) / 2;
-                    if (Clear(point + (toward - point) * middle))
+                    if (Clear(point + (pole - point) * middle))
                         high = middle;
                     else
                         low = middle;
                 }
-                pierce = point + (toward - point) * high;
+                pierce = point + (pole - point) * high;
             }
 
             var length = pierce.DistanceTo(point);
             if (length <= Math.Tolerance.Epsilon)
                 return leadIn;
-            var direction = PortableMath.Atan2(pierce.Y - point.Y, pierce.X - point.X);
+            var direction = System.Math.Atan2(pierce.Y - point.Y, pierce.X - point.X);
             return new LineLeadIn
             {
                 Length = length,
@@ -1264,115 +1114,19 @@ namespace OpenNest.CNC.CuttingStrategy
                 && hole.ClosestPointTo(p, out _).DistanceTo(p) >= pierceRadius;
         }
 
-        /// <summary>
-        /// Keeps a cutout's lead-in out of the cutout's far half. A lead longer than the cutout is
-        /// deep at its entry, measured straight in from the wall to the center line where the walls
-        /// meet as the cutout erodes, reaches past the center line or runs along a narrow stroke, as
-        /// does one whose own line gets closer to a wall again. It becomes a straight one, generated
-        /// with <paramref name="normal"/>, from that center line (the center of a round hole) or
-        /// from the lead's own length in when that comes first. Any other lead keeps its shape, and
-        /// one that leaves a cutout other than a round hole is left for the lead check to refuse.
-        /// </summary>
-        public static LeadIn StopAtCenterLine(Shape hole, Vector point, LeadIn leadIn, double normal, RotationType turn)
-        {
-            if (leadIn is NoLeadIn || !hole.IsClosed())
-                return leadIn;
-            var pierce = leadIn.GetPiercePoint(point, normal, turn);
-            var length = pierce.DistanceTo(point);
-            if (!double.IsFinite(length) || length <= Math.Tolerance.Epsilon)
-                return leadIn;
-
-            var circle = hole.Entities.Count == 1 ? hole.Entities[0] as Circle : null;
-            var along = pierce - point;
-            var inward = Inward(normal);
-            // A pierce as far from every wall as it is deep has not come near another wall.
-            var inside = circle == null || pierce.DistanceTo(circle.Center) < circle.Radius;
-            if (inside && Clearance(hole, pierce) >= along.X * inward.X + along.Y * inward.Y - Math.Tolerance.Epsilon)
-                return leadIn;
-
-            var depth = CenterLineDepth(hole, point, normal, length);
-            if (depth <= Math.Tolerance.Epsilon
-                || inside && depth >= length - Math.Tolerance.Epsilon && !PeaksBeforeItsEnd(hole, point, along))
-                return leadIn;
-            if (circle == null)
-            {
-                var polygon = hole.ToPolygonWithTolerance(Math.Tolerance.ChainTolerance);
-                for (var i = 1; i <= CenterLineSteps; i++)
-                    if (!polygon.ContainsPoint(point + along * ((double)i / CenterLineSteps)))
-                        return leadIn;
-            }
-            return new LineLeadIn { Length = depth, ApproachAngle = 90 };
-        }
-
-        // How far a straight line in from the wall runs, up to maxDepth, before it reaches the
-        // center line: the distance to the wall grows at a steady rate until a second wall is as
-        // near, then levels off along a stroke or falls.
-        private static double CenterLineDepth(Shape hole, Vector point, double normal, double maxDepth)
-        {
-            if (hole.Entities.Count == 1 && hole.Entities[0] is Circle circle)
-                return System.Math.Min(maxDepth, circle.Radius);
-
-            var inward = Inward(normal);
-            var step = maxDepth / CenterLineSteps;
-            var rate = Clearance(hole, point + inward * step) / step;
-            // A corner's curved lead keeps an edge's normal, which runs along the other edge.
-            if (rate < MinimumCenterLineRate)
-                return maxDepth;
-            bool Rising(double depth) => Clearance(hole, point + inward * (depth + step / CenterLineSteps))
-                - Clearance(hole, point + inward * depth) >= rate / 2 * (step / CenterLineSteps);
-            for (var i = 1; i < CenterLineSteps; i++)
-            {
-                if (Rising(step * i))
-                    continue;
-                double low = step * (i - 1), high = step * i;
-                for (var refine = 0; refine < CenterLineRefinements; refine++)
-                {
-                    var middle = (low + high) / 2;
-                    if (Rising(middle))
-                        low = middle;
-                    else
-                        high = middle;
-                }
-                return low;
-            }
-            return maxDepth;
-        }
-
-        private static bool PeaksBeforeItsEnd(Shape hole, Vector point, Vector along)
-        {
-            var peak = 0.0;
-            for (var i = 1; i <= CenterLineSteps; i++)
-            {
-                var clearance = Clearance(hole, point + along * ((double)i / CenterLineSteps));
-                if (clearance < peak - Math.Tolerance.Epsilon)
-                    return true;
-                peak = System.Math.Max(peak, clearance);
-            }
-            return false;
-        }
-
-        private static double Clearance(Shape hole, Vector point) => hole.ClosestPointTo(point, out _).DistanceTo(point);
-
-        private static Vector Inward(double normal) => new(PortableMath.Cos(normal), PortableMath.Sin(normal));
-
         /// <summary>
         /// A straight lead-in from <paramref name="pierce"/> to <paramref name="point"/>, with the
         /// normal to generate it with.
         /// </summary>
         private static LeadIn StraightLeadIn(Vector point, Vector pierce, out double normal)
         {
-            normal = PortableMath.Atan2(pierce.Y - point.Y, pierce.X - point.X);
+            normal = System.Math.Atan2(pierce.Y - point.Y, pierce.X - point.X);
             return new LineLeadIn { Length = pierce.DistanceTo(point), ApproachAngle = 90 };
         }
 
         // Bounds the pole search on long, thin holes; the result is checked before use.
         private const int PoleSearchCells = 4096;
 
-        // Samples along a lead when looking for the center line, then the steps narrowing in on it.
-        private const int CenterLineSteps = 64;
-        private const int CenterLineRefinements = 16;
-        private const double MinimumCenterLineRate = 0.01;
-
         private LeadIn SelectLeadIn(ContourType contourType)
         {
             return contourType switch
@@ -1393,22 +1147,6 @@ namespace OpenNest.CNC.CuttingStrategy
 
         private static Shape TrimShapeForTab(Shape shape, Vector center, double tabSize)
         {
-            // A round perimeter is one circle entered at `center`: cut it as an arc from the entry
-            // that stops the tab's chord short of it, travelling the circle's own way.
-            if (shape.Entities is [Circle round] && round.Radius > tabSize / 2)
-            {
-                var entry = round.Center.AngleTo(center);
-                var gap = 2 * PortableMath.Asin(tabSize / (2 * round.Radius));
-                var reversed = round.Rotation == RotationType.CW;
-                var arc = new Arc(round.Center, round.Radius, entry, reversed ? entry + gap : entry - gap, reversed)
-                {
-                    Layer = round.Layer,
-                };
-                var trimmed = new Shape();
-                trimmed.Entities.Add(arc);
-                return trimmed;
-            }
-
             var tabCircle = new Circle(center, tabSize);
             var entities = new List<Entity>(shape.Entities);
 
@@ -1578,30 +1316,14 @@ namespace OpenNest.CNC.CuttingStrategy
                     path = (Shape)cut.Clone();
                     path.Reverse();
                 }
-                var normal = Angle.NormalizeRad(PortableMath.Atan2(scrap.Y, scrap.X));
+                var normal = Angle.NormalizeRad(System.Math.Atan2(scrap.Y, scrap.X));
                 program.Codes.AddRange(leadIn.Generate(entry, normal, fromEnd ? RotationType.CW : RotationType.CCW));
                 program.Codes.AddRange(ConvertShapeToMoves(path, entry, LayerType.Break));
             }
         }
 
-        // Each slug slice is a break cut inside its cutout's slug: pierced on itself, led straight
-        // back along itself to its start, then cut. It has no lead-out and keeps the kerf from
-        // the cutout, so its slug's pieces stay attached until the cutout is cut.
-        private static void EmitSlugSlices(Program program, IReadOnlyList<Support.SlugSlice> slices)
-        {
-            if (slices == null)
-                return;
-            foreach (var slice in slices)
-            {
-                program.Codes.Add(new RapidMove(slice.Pierce));
-                if (slice.Pierce.DistanceTo(slice.Start) > Tolerance.Epsilon)
-                    program.Codes.Add(new LinearMove(slice.Start) { Layer = LayerType.Leadin });
-                program.Codes.Add(new LinearMove(slice.End) { Layer = LayerType.Break });
-            }
-        }
-
         /// <summary>
-        /// Where a break cut (traveling with its scrap on the left) is entered: the end with more
+        /// Where a break cut (travelling with its scrap on the left) is entered: the end with more
         /// scrap before <paramref name="contours"/>, the unit direction into the scrap there, and
         /// whether that is the cut's far end.
         /// </summary>
@@ -1617,78 +1339,6 @@ namespace OpenNest.CNC.CuttingStrategy
                 : (start, startScrap, false);
         }
 
-        /// <summary>
-        /// A common-line member's outside around the shared spans earlier members cut (on the Tab
-        /// layer; docs/common-line-cutting.md), each piece in the perimeter's own direction. With a
-        /// common-line entry, the first piece starts there, pierced in scrap with a straight lead-in
-        /// along the shared edge, and runs to the next span; the stretch before the entry is cut
-        /// last and ends at it. Every other piece starts where a shared span ends. It is pierced in that span's opened
-        /// kerf on the centerline, the external lead-in's reach back along the span, and enters along
-        /// a straight lead-in that ends at the piece's start, so compensation starts in the kerf. It
-        /// has no lead-out: it ends in the kerf at the next shared span. Capture checks that every
-        /// lead fits; emission never shortens one.
-        /// </summary>
-        private void EmitCommonLinePerimeter(Program program, Shape perimeter, CuttingPlanning.CommonLinePerimeter commonLine)
-        {
-            var winding = DetermineWinding(perimeter);
-            var leadIn = Parameters?.ExternalLeadIn ?? new NoLeadIn();
-            var entities = perimeter.Entities;
-            var pieces = TabbedCutoutPieces(perimeter);
-            if (commonLine.Entry is { } start && commonLine.Pierce is { } pierce)
-            {
-                // The piece holding the entry is cut from it to its end first, then the pieces after
-                // it in travel order, and its stretch before the entry last.
-                var at = pieces.FindIndex(p => p.Entities.Exists(e => EntityStartPoint(e).DistanceTo(start) <= Tolerance.Epsilon));
-                var piece = pieces[at];
-                var split = piece.Entities.FindIndex(e => EntityStartPoint(e).DistanceTo(start) <= Tolerance.Epsilon);
-                var head = new Shape();
-                head.Entities.AddRange(piece.Entities.Skip(split));
-                program.Codes.Add(new RapidMove(pierce));
-                program.Codes.Add(new Comment(CommonLineCuts.RemainderMarker(winding)));
-                program.Codes.Add(new LinearMove(start) { Layer = LayerType.Leadin });
-                program.Codes.AddRange(ConvertShapeToMoves(head, start));
-                var rest = pieces.Skip(at + 1).Concat(pieces.Take(at)).ToList();
-                if (split > 0)
-                {
-                    var tail = new Shape();
-                    tail.Entities.AddRange(piece.Entities.Take(split));
-                    rest.Add(tail);
-                }
-                pieces = rest;
-            }
-            foreach (var piece in pieces)
-            {
-                var first = piece.Entities[0];
-                var index = entities.IndexOf(first);
-                var span = (Line)entities[(index + entities.Count - 1) % entities.Count];
-                var entry = EntityStartPoint(first);
-                program.Codes.Add(new RapidMove(CommonLineRemainderPierce(span, winding, commonLine.Kerf,
-                    CommonLineLeadInReach(leadIn))));
-                // Posts compensate a remainder on its perimeter's side: it encloses nothing itself.
-                program.Codes.Add(new Comment(CommonLineCuts.RemainderMarker(winding)));
-                program.Codes.Add(new LinearMove(entry) { Layer = LayerType.Leadin });
-                program.Codes.AddRange(ConvertShapeToMoves(piece, entry));
-            }
-        }
-
-        /// <summary>
-        /// The pierce of a common-line remainder entered at the end of <paramref name="span"/> (a
-        /// straight shared span of a perimeter wound <paramref name="winding"/>): on the shared
-        /// centerline, half the <paramref name="kerf"/> outside the span, <paramref name="reach"/>
-        /// back along it from the piece's start.
-        /// </summary>
-        internal static Vector CommonLineRemainderPierce(Line span, RotationType winding, double kerf, double reach)
-        {
-            var along = (span.EndPoint - span.StartPoint).Normalize();
-            // Material lies left of a counterclockwise perimeter's travel, so outside is right.
-            var outward = winding == RotationType.CCW ? new Vector(along.Y, -along.X) : new Vector(-along.Y, along.X);
-            return span.EndPoint - along * reach + outward * (kerf / 2);
-        }
-
-        /// <summary>How far a common-line lead-in reaches: the external lead-in's pierce distance.</summary>
-        internal static double CommonLineLeadInReach(LeadIn leadIn) =>
-            leadIn.GetPiercePoint(Vector.Zero, 0, RotationType.CW).DistanceTo(Vector.Zero);
-
         /// <summary>Whether <paramref name="shape"/> has <see cref="SpecialLayers.Tab"/> spans: a tabbed cutout.</summary>
         internal static bool IsTabbedCutout(Shape shape) => shape.Entities.Exists(e => e.Layer == SpecialLayers.Tab);
 
@@ -1799,9 +1449,9 @@ namespace OpenNest.CNC.CuttingStrategy
 
         private static bool OnArc(Vector center, Vector start, Vector end, Vector point, RotationType rotation)
         {
-            var a0 = PortableMath.Atan2(start.Y - center.Y, start.X - center.X);
+            var a0 = System.Math.Atan2(start.Y - center.Y, start.X - center.X);
-            var a1 = PortableMath.Atan2(end.Y - center.Y, end.X - center.X);
+            var a1 = System.Math.Atan2(end.Y - center.Y, end.X - center.X);
-            var ap = PortableMath.Atan2(point.Y - center.Y, point.X - center.X);
+            var ap = System.Math.Atan2(point.Y - center.Y, point.X - center.X);
             var sign = rotation == RotationType.CCW ? 1 : -1;
             var sweep = Angle.NormalizeRad(sign * (a1 - a0));
             if (sweep <= Tolerance.Epsilon)
@@ -1858,8 +1508,8 @@ namespace OpenNest.CNC.CuttingStrategy
             {
                 var angle = atEnd ? arc.EndAngle : arc.StartAngle;
                 return arc.IsReversed
-                    ? new Vector(PortableMath.Sin(angle), -PortableMath.Cos(angle))
+                    ? new Vector(System.Math.Sin(angle), -System.Math.Cos(angle))
-                    : new Vector(-PortableMath.Sin(angle), PortableMath.Cos(angle));
+                    : new Vector(-System.Math.Sin(angle), System.Math.Cos(angle));
             }
             var line = (Line)entity;
             return line.EndPoint - line.StartPoint;

OpenNest.Core/CNC/CuttingStrategy/CuttingParameters.cs

@@ -42,77 +42,54 @@ namespace OpenNest.CNC.CuttingStrategy
         public double LeadInAngleIncrement { get; set; } = 5.0;
 
         public Tab TabConfig { get; set; }
-
-        /// <summary>
-        /// Whether a contour is cut with a tab at its entry. The cutting settings never set it for
-        /// every part: Plan Cutting, Place Lead-in and drawing pins set it on the copies of the
-        /// settings they give the parts they tab. Parameters recorded with it on replay as planned.
-        /// </summary>
         public bool TabsEnabled { get; set; }
 
         /// <summary>
-        /// Tabs the parts that need one (see docs/support-tabs.md): with <see cref="TabBySize"/>
+        /// Tabs each part its plate's support bed cannot hold level once it is cut free, at the
-        /// off, each part its plate's support bed cannot hold level once it is cut free, at the
+        /// perimeter point that best keeps its center of gravity over the bed's contacts (see
-        /// perimeter point that best keeps its center of gravity over the bed's contacts, or on a
+        /// docs/support-tabs.md). Needs <see cref="TabConfig"/> for the tab size.
-        /// plate with no bed each part in the size range; with it on, each part in the size range.
-        /// Needs <see cref="TabConfig"/> for the tab size.
         /// </summary>
         public bool SupportTabs { get; set; }
 
         /// <summary>
-        /// With <see cref="SupportTabs"/>, ignore the support bed and tab every part whose width is
+        /// With <see cref="SupportTabs"/> on a plate that has no support bed, the narrowest part
-        /// in <see cref="TabSizeMinWidth"/> to <see cref="TabSizeMaxWidth"/>
+        /// width that is tabbed instead (see <see cref="TabsWithoutBedAt"/>).
-        /// (<see cref="TabsBySizeAt"/>).
         /// </summary>
-        public bool TabBySize { get; set; }
+        public double NoBedTabMinWidth { get; set; }
 
         /// <summary>
-        /// The narrowest part width that is tabbed by size: with <see cref="TabBySize"/>, or with
+        /// With <see cref="SupportTabs"/> on a plate that has no support bed, the widest part
-        /// <see cref="SupportTabs"/> on a plate that has no support bed (see <see cref="TabsBySizeAt"/>).
+        /// width that is tabbed instead; 0 turns the rule off, so nothing is tabbed without a bed.
         /// </summary>
-        public double TabSizeMinWidth { get; set; }
+        public double NoBedTabMaxWidth { get; set; }
 
-        /// <summary>
+        /// <summary>Whether <see cref="NoBedTabMinWidth"/> to <see cref="NoBedTabMaxWidth"/> is a usable range.</summary>
-        /// The widest part width that is tabbed by size; 0 turns the rule off, so nothing is
+        public bool HasNoBedTabRange() =>
-        /// tabbed by size.
+            NoBedTabMaxWidth > 0 && double.IsFinite(NoBedTabMaxWidth)
-        /// </summary>
+            && NoBedTabMinWidth >= 0 && NoBedTabMinWidth <= NoBedTabMaxWidth;
-        public double TabSizeMaxWidth { get; set; }
-
-        /// <summary>Whether <see cref="TabSizeMinWidth"/> to <see cref="TabSizeMaxWidth"/> is a usable range.</summary>
-        public bool HasTabSizeRange() =>
-            TabSizeMaxWidth > 0 && double.IsFinite(TabSizeMaxWidth)
-            && TabSizeMinWidth >= 0 && TabSizeMinWidth <= TabSizeMaxWidth;
 
         /// <summary>
         /// Whether a part <paramref name="width"/> wide (the short side of its minimum-area
-        /// bounding rectangle) is tabbed by size.
+        /// bounding rectangle) is tabbed when its plate has no support bed.
         /// </summary>
-        public bool TabsBySizeAt(double width) =>
+        public bool TabsWithoutBedAt(double width) =>
-            HasTabSizeRange()
+            HasNoBedTabRange()
-            && width >= TabSizeMinWidth - Math.Tolerance.Epsilon
+            && width >= NoBedTabMinWidth - Math.Tolerance.Epsilon
-            && width <= TabSizeMaxWidth + Math.Tolerance.Epsilon;
+            && width <= NoBedTabMaxWidth + Math.Tolerance.Epsilon;
 
         /// <summary>
         /// With <see cref="SupportTabs"/> on a plate with a support bed, the longest part (the
         /// long side of its outline's minimum-area bounding rectangle) its tab alone holds: such a
         /// part the bed cannot hold level is tabbed, and any tab clear of inside corners steadies
-        /// it. 0 turns the rule off. New settings start at 6; settings saved without it read as 0.
+        /// it. 0 turns the rule off.
         /// </summary>
-        public double TabHeldMaxLength { get; set; } = 6;
+        public double TabHeldMaxLength { get; set; }
 
         /// <summary>Whether a part <paramref name="length"/> long is held by its tab alone (see <see cref="TabHeldMaxLength"/>).</summary>
         public bool TabHoldsAt(double length) =>
             TabHeldMaxLength > 0 && double.IsFinite(TabHeldMaxLength)
             && length <= TabHeldMaxLength + Math.Tolerance.Epsilon;
 
-        /// <summary>
-        /// Slices the slug of each cutout its plate's support bed cannot hold level along the
-        /// bed's contact lines before the cutout is cut, so the slug drops as pieces between the
-        /// supports instead of tipping (see docs/support-tabs.md#slug-slices). Each slice stops
-        /// <see cref="Kerf"/> short of the cutout, so nothing is sliced without a kerf.
-        /// </summary>
-        public bool SliceTippingSlugs { get; set; }
-
         public SequenceParameters Sequencing { get; set; } = new SequenceParameters();
         public AssignmentParameters Assignment { get; set; } = new AssignmentParameters();
     }

OpenNest.Core/CNC/CuttingStrategy/ErodedPierce.cs

@@ -19,10 +19,10 @@ namespace OpenNest.CNC.CuttingStrategy
     /// <summary>
     /// The pierce search for cutouts too small for their configured lead-in (text, slots, small
     /// holes): erode the cutout inward, as a laser kerf offset would, and pierce in what is left.
-    /// The erosion goes as deep as the caller asks when the cutout has room for it, else almost
+    /// The erosion goes as deep as the pierce clearance when the cutout has room for it, else
-    /// to its pole of inaccessibility; a round hole is pierced at its center. Each target, an entry the planner ranked, gets the
+    /// almost to its pole of inaccessibility. Each target, an entry the planner ranked, gets the
     /// nearest point of the deepest erosion that still reaches the wall beside it, stepping down to
-    /// half that depth: a letter stroke is pierced on its own center line next to the entry, and
+    /// half that depth: a letter stroke is pierced on its own centre line next to the entry, and
     /// only a target with no stroke beside it falls back to the deepest place. The lead then runs
     /// straight from the pierce to the wall.
     /// </summary>
@@ -30,7 +30,7 @@ namespace OpenNest.CNC.CuttingStrategy
     {
         /// <summary>
         /// The share of a cutout's inscribed radius the erosion keeps when the full clearance does
-        /// not fit: deep enough to stay near the center line, with room for every place the
+        /// not fit: deep enough to stay near the centre line, with room for every place the
         /// cutout is about as wide as its widest.
         /// </summary>
         public const double DepthFraction = 0.9;
@@ -47,10 +47,10 @@ namespace OpenNest.CNC.CuttingStrategy
         /// too small to erode is pierced at its pole for every target. Nothing for an open or
         /// degenerate contour.
         /// </summary>
-        public static ErodedPierces Find(Shape hole, double depth, IReadOnlyList<Vector> targets, int max)
+        public static ErodedPierces Find(Shape hole, double clearance, IReadOnlyList<Vector> targets, int max)
         {
             if (hole == null || !hole.IsClosed() || targets == null || targets.Count == 0 || max <= 0
-                || !double.IsFinite(depth))
+                || !double.IsFinite(clearance))
                 return ErodedPierces.None;
 
             // The inscribed radius, from the true wall: the deepest any erosion can go.
@@ -64,12 +64,10 @@ namespace OpenNest.CNC.CuttingStrategy
             var inscribed = hole.ClosestPointTo(pole, out _).DistanceTo(pole);
             if (!(inscribed > 0))
                 return ErodedPierces.None;
-            if (hole.Entities.Count == 1 && hole.Entities[0] is Circle circle)
-                return new(targets.Take(max).Select(_ => circle.Center).ToArray(), circle.Radius);
 
             // Inscribed flattening can stand off a concave arc, and round joins cut their arcs,
             // each by the tolerance; Clipper rounds to its precision. Erode past both.
-            depth = System.Math.Min(System.Math.Max(depth, 0), inscribed * DepthFraction);
+            var depth = System.Math.Min(System.Math.Max(clearance, 0), inscribed * DepthFraction);
             var tolerance = System.Math.Max(depth / 100, System.Math.Pow(10, -ClipperBridge.Precision));
             var margin = 2 * tolerance + System.Math.Pow(10, -ClipperBridge.Precision);
             if (depth + margin >= inscribed - tolerance)
@@ -86,7 +84,7 @@ namespace OpenNest.CNC.CuttingStrategy
                 return new(targets.Take(max).Select(_ => pole).ToArray(), inscribed);
 
             // Each target gets the deepest level that reaches the wall beside it: a stroke
-            // narrower than the cutout's widest place is still pierced on its own center line, near
+            // narrower than the cutout's widest place is still pierced on its own centre line, near
             // the entry, rather than only at the widest place.
             var pierces = new List<Vector>();
             var shallowest = depth;

OpenNest.Core/CNC/CuttingStrategy/LeadIns/ArcLeadIn.cs

@@ -46,8 +46,8 @@ namespace OpenNest.CNC.CuttingStrategy
             var angle = contourNormalAngle + (winding == RotationType.CCW ? shortfall : -shortfall);
             var center = ArcCenter(contourStartPoint, contourNormalAngle);
             return new Vector(
-                center.X + Radius * PortableMath.Cos(angle),
+                center.X + Radius * System.Math.Cos(angle),
-                center.Y + Radius * PortableMath.Sin(angle)
+                center.Y + Radius * System.Math.Sin(angle)
             );
         }
 
@@ -55,8 +55,8 @@ namespace OpenNest.CNC.CuttingStrategy
             new ArcLeadIn { Radius = Radius * factor, SweepAngle = SweepAngle };
 
         private Vector ArcCenter(Vector contourStartPoint, double contourNormalAngle) => new Vector(
-            contourStartPoint.X + Radius * PortableMath.Cos(contourNormalAngle),
+            contourStartPoint.X + Radius * System.Math.Cos(contourNormalAngle),
-            contourStartPoint.Y + Radius * PortableMath.Sin(contourNormalAngle)
+            contourStartPoint.Y + Radius * System.Math.Sin(contourNormalAngle)
         );
     }
 }

OpenNest.Core/CNC/CuttingStrategy/LeadIns/LineArcApproach.cs

@@ -28,22 +28,22 @@ namespace OpenNest.CNC.CuttingStrategy
         public static LineArcApproach Create(Vector contourStartPoint, double contourNormalAngle,
             double arcRadius, double approachAngle, double lineLength, RotationType winding)
         {
-            var arcCenterX = contourStartPoint.X + arcRadius * PortableMath.Cos(contourNormalAngle);
+            var arcCenterX = contourStartPoint.X + arcRadius * System.Math.Cos(contourNormalAngle);
-            var arcCenterY = contourStartPoint.Y + arcRadius * PortableMath.Sin(contourNormalAngle);
+            var arcCenterY = contourStartPoint.Y + arcRadius * System.Math.Sin(contourNormalAngle);
 
             // The approach angle is measured back from the normal against the turn, so the arc
             // runs the short way round to the contour point whichever way it turns.
             var approach = Angle.ToRadians(approachAngle);
             var lineAngle = contourNormalAngle + (winding == RotationType.CCW ? approach : -approach);
-            var arcStartX = arcCenterX + arcRadius * PortableMath.Cos(lineAngle);
+            var arcStartX = arcCenterX + arcRadius * System.Math.Cos(lineAngle);
-            var arcStartY = arcCenterY + arcRadius * PortableMath.Sin(lineAngle);
+            var arcStartY = arcCenterY + arcRadius * System.Math.Sin(lineAngle);
 
             return new LineArcApproach(
                 new Vector(arcCenterX, arcCenterY),
                 new Vector(arcStartX, arcStartY),
                 new Vector(
-                    arcStartX + lineLength * PortableMath.Cos(lineAngle),
+                    arcStartX + lineLength * System.Math.Cos(lineAngle),
-                    arcStartY + lineLength * PortableMath.Sin(lineAngle)));
+                    arcStartY + lineLength * System.Math.Sin(lineAngle)));
         }
 
         /// <summary>Rapid to the pierce point, then the line and arc on the lead-in layer.</summary>

OpenNest.Core/CNC/CuttingStrategy/LeadIns/LineLeadIn.cs

@@ -29,8 +29,8 @@ namespace OpenNest.CNC.CuttingStrategy
         {
             var approachAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle);
             return new Vector(
-                contourStartPoint.X + Length * PortableMath.Cos(approachAngle),
+                contourStartPoint.X + Length * System.Math.Cos(approachAngle),
-                contourStartPoint.Y + Length * PortableMath.Sin(approachAngle)
+                contourStartPoint.Y + Length * System.Math.Sin(approachAngle)
             );
         }
 

OpenNest.Core/CNC/CuttingStrategy/LeadIns/LineLineLeadIn.cs

@@ -21,8 +21,8 @@ namespace OpenNest.CNC.CuttingStrategy
 
             var secondAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle1);
             var midPoint = new Vector(
-                contourStartPoint.X + Length2 * PortableMath.Cos(secondAngle),
+                contourStartPoint.X + Length2 * System.Math.Cos(secondAngle),
-                contourStartPoint.Y + Length2 * PortableMath.Sin(secondAngle)
+                contourStartPoint.Y + Length2 * System.Math.Sin(secondAngle)
             );
 
             return new List<ICode>
@@ -37,13 +37,13 @@ namespace OpenNest.CNC.CuttingStrategy
             RotationType winding = RotationType.CW)
         {
             var secondAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle1);
-            var midX = contourStartPoint.X + Length2 * PortableMath.Cos(secondAngle);
+            var midX = contourStartPoint.X + Length2 * System.Math.Cos(secondAngle);
-            var midY = contourStartPoint.Y + Length2 * PortableMath.Sin(secondAngle);
+            var midY = contourStartPoint.Y + Length2 * System.Math.Sin(secondAngle);
 
             var firstAngle = secondAngle + Angle.ToRadians(ApproachAngle2);
             return new Vector(
-                midX + Length1 * PortableMath.Cos(firstAngle),
+                midX + Length1 * System.Math.Cos(firstAngle),
-                midY + Length1 * PortableMath.Sin(firstAngle)
+                midY + Length1 * System.Math.Sin(firstAngle)
             );
         }
 

OpenNest.Core/CNC/CuttingStrategy/LeadOuts/ArcLeadOut.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using OpenNest.Geometry;
-using OpenNest.Math;
 
 namespace OpenNest.CNC.CuttingStrategy
 {
@@ -18,16 +17,16 @@ namespace OpenNest.CNC.CuttingStrategy
             RotationType winding = RotationType.CW
         )
         {
-            var arcCenterX = contourEndPoint.X + Radius * PortableMath.Cos(contourNormalAngle);
+            var arcCenterX = contourEndPoint.X + Radius * System.Math.Cos(contourNormalAngle);
-            var arcCenterY = contourEndPoint.Y + Radius * PortableMath.Sin(contourNormalAngle);
+            var arcCenterY = contourEndPoint.Y + Radius * System.Math.Sin(contourNormalAngle);
             var arcCenter = new Vector(arcCenterX, arcCenterY);
 
             // The contour point sits opposite the normal from the center; turn a quarter on.
             var endAngle = contourNormalAngle
                 + (winding == RotationType.CCW ? -System.Math.PI / 2 : System.Math.PI / 2);
             var endPoint = new Vector(
-                arcCenterX + Radius * PortableMath.Cos(endAngle),
+                arcCenterX + Radius * System.Math.Cos(endAngle),
-                arcCenterY + Radius * PortableMath.Sin(endAngle)
+                arcCenterY + Radius * System.Math.Sin(endAngle)
             );
 
             return new List<ICode>

OpenNest.Core/CNC/CuttingStrategy/LeadOuts/LineLeadOut.cs

@@ -17,8 +17,8 @@ namespace OpenNest.CNC.CuttingStrategy
         {
             var overcutAngle = contourNormalAngle + Angle.HalfPI - Angle.ToRadians(ApproachAngle);
             var endPoint = new Vector(
-                contourEndPoint.X + Length * PortableMath.Cos(overcutAngle),
+                contourEndPoint.X + Length * System.Math.Cos(overcutAngle),
-                contourEndPoint.Y + Length * PortableMath.Sin(overcutAngle)
+                contourEndPoint.Y + Length * System.Math.Sin(overcutAngle)
             );
 
             return new List<ICode> { new LinearMove(endPoint) { Layer = LayerType.Leadout } };

OpenNest.Core/CNC/CuttingStrategy/PierceZoneMemo.cs

@@ -1,65 +0,0 @@
-using System;
-using System.Collections.Generic;
-using OpenNest.Geometry;
-
-namespace OpenNest.CNC.CuttingStrategy
-{
-    /// <summary>
-    /// Remembers <see cref="ContourCuttingStrategy.ResolvePierceZone"/> for one preparation's
-    /// contours. The resolution reads only the cutout's own geometry, the entry, the configured
-    /// lead-in and the zone, so for a given contour it is a pure function of those, yet the
-    /// search emits every contour of a part's chain again on every expansion, and on a cutout
-    /// whose configured pierce is inside the zone each resolution flattens the cutout, finds its
-    /// pole and erodes it. One memo serves every emission of one <c>PreparedContours</c> and
-    /// its copies, which share the contours by ordinal. A lead-in a memo returns is shared and
-    /// must not be mutated.
-    /// </summary>
-    internal sealed class PierceZoneMemo
-    {
-        private readonly Dictionary<Key, LeadIn> resolved = new();
-        private readonly object gate = new();
-
-        /// <summary>How many resolutions the memo answered without computing; for tests.</summary>
-        internal int Hits { get; private set; }
-
-        internal LeadIn Resolve(int contour, Shape hole, Vector point, LeadIn leadIn, double normal,
-            double pierceRadius, RotationType turn)
-        {
-            if (KeyOf(leadIn) is not { } lead)
-                return ContourCuttingStrategy.ResolvePierceZone(hole, point, leadIn, normal, pierceRadius, turn);
-            var key = new Key(contour, point.X, point.Y, normal, pierceRadius, turn, lead);
-            lock (gate)
-            {
-                if (resolved.TryGetValue(key, out var known))
-                {
-                    Hits++;
-                    return known;
-                }
-            }
-            var result = ContourCuttingStrategy.ResolvePierceZone(hole, point, leadIn, normal, pierceRadius, turn);
-            lock (gate)
-            {
-                resolved[key] = result;
-            }
-            return result;
-        }
-
-        // The configured lead-in by value: an equal lead-in resolves the same way whichever
-        // instance carries it. A lead-in type this does not know is resolved every time.
-        private static LeadKey? KeyOf(LeadIn leadIn) => leadIn switch
-        {
-            NoLeadIn => new(0, 0, 0, 0, 0),
-            LineLeadIn line => new(1, line.Length, line.ApproachAngle, 0, 0),
-            ArcLeadIn arc => new(2, arc.Radius, arc.SweepAngle, 0, 0),
-            LineArcLeadIn lineArc => new(3, lineArc.LineLength, lineArc.ApproachAngle, lineArc.ArcRadius, 0),
-            CleanHoleLeadIn cleanHole => new(4, cleanHole.LineLength, cleanHole.ArcRadius, cleanHole.Kerf, 0),
-            LineLineLeadIn lineLine => new(5, lineLine.Length1, lineLine.ApproachAngle1, lineLine.Length2, lineLine.ApproachAngle2),
-            _ => null,
-        };
-
-        private readonly record struct LeadKey(int Kind, double A, double B, double C, double D);
-
-        private readonly record struct Key(int Contour, double X, double Y, double Normal, double PierceRadius,
-            RotationType Turn, LeadKey Lead);
-    }
-}

OpenNest.Core/CNC/CuttingStrategy/Tabs/BreakerTab.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using OpenNest.Geometry;
-using OpenNest.Math;
 
 namespace OpenNest.CNC.CuttingStrategy
 {
@@ -24,8 +23,8 @@ namespace OpenNest.CNC.CuttingStrategy
 
             var scoreAngle = contourNormalAngle + System.Math.PI;
             var scoreEnd = new Vector(
-                tabStartPoint.X + BreakerDepth * PortableMath.Cos(scoreAngle),
+                tabStartPoint.X + BreakerDepth * System.Math.Cos(scoreAngle),
-                tabStartPoint.Y + BreakerDepth * PortableMath.Sin(scoreAngle)
+                tabStartPoint.Y + BreakerDepth * System.Math.Sin(scoreAngle)
             );
             codes.Add(new LinearMove(scoreEnd));
             codes.Add(new RapidMove(tabEndPoint));

OpenNest.Core/CNC/HeadHeightLock.cs

@@ -73,12 +73,31 @@ namespace OpenNest.CNC
         /// Refuses a nest a post cannot write, before any output is created: a cut-off with a locked
         /// overcut needs the post's lock and unlock codes, and its markers must be well formed.
         /// </summary>
-        public static void EnsurePostable(Nest nest, bool hasCodes, string postName) =>
+        public static void EnsurePostable(Nest nest, bool hasCodes, string postName)
-            PostMarkers.EnsurePostable(nest, hasCodes, IsMarked, program => LockedMask(program.Codes),
+        {
-                name => $"{name} overcuts past the sheet edge with the head height locked, but the "
+            ArgumentNullException.ThrowIfNull(nest);
-                    + $"{postName} post has no head-height lock and unlock codes. Enter them in "
+            foreach (var plate in nest.Plates)
-                    + $"\"Head height lock\" and \"Head height unlock\" in the {postName} Settings "
+            {
-                    + "dialog, which opens when you post, or delete the cut-off and add it again "
+                foreach (var part in plate.Parts)
-                    + "with \"Lock head height and overcut the far edge\" unchecked.");
+                {
+                    if (part?.Program == null || !IsMarked(part.Program))
+                        continue;
+                    var name = DisplayPerimeterTail.PartName(part);
+                    if (!hasCodes)
+                        throw new InvalidOperationException(
+                            $"{name} overcuts past the sheet edge with the head height locked, but the {postName} post "
+                            + "has no head-height lock and unlock codes. Enter them in the post's configuration, "
+                            + "or delete the cut-off and add it again with the head-height lock off.");
+                    try
+                    {
+                        LockedMask(part.Program.Codes);
+                    }
+                    catch (ArgumentException ex)
+                    {
+                        throw new InvalidOperationException($"{name} cannot be posted: {ex.Message}", ex);
+                    }
+                }
+            }
+        }
     }
 }

OpenNest.Core/CNC/HeadRaise.cs

@@ -1,87 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace OpenNest.CNC
-{
-    /// <summary>
-    /// A rapid the head must make raised because it passes over parts already cut, which may have
-    /// tipped. Plan Cutting marks such a rapid only when no route avoids the crossing, and always
-    /// marks the rapid out of a cutout's slug after its lead-out (see docs/cutting-planner.md): a
-    /// <see cref="Marker"/> comment immediately before the <see cref="RapidMove"/>, or before the
-    /// <see cref="SubProgramCall"/> whose arrival rapid it is, since a sub-program may be shared and
-    /// is never marked itself. Rapid checks accept a crossing on a marked rapid. Posts write their machine's head raise before every marked rapid,
-    /// and refuse to post a marked program when they have none, since the rapid is unsafe head down.
-    /// See docs/cutting-planner.md.
-    /// </summary>
-    public static class HeadRaise
-    {
-        /// <summary>The comment immediately before a rapid made with the head raised.</summary>
-        public const string Marker = "HEAD RAISE";
-
-        public static bool IsMarker(ICode code) => code is Comment { Value: Marker };
-
-        /// <summary>Whether <paramref name="program"/>'s own codes hold a marker.</summary>
-        public static bool IsMarked(Program program)
-        {
-            if (program?.Codes == null)
-                return false;
-            foreach (var code in program.Codes)
-                if (IsMarker(code))
-                    return true;
-            return false;
-        }
-
-        /// <summary>
-        /// For each of <paramref name="codes"/>, whether it is a rapid made with the head raised, or a
-        /// sub-program call whose arrival rapid is. A marker must be followed directly by a rapid or
-        /// a call; anything else is a malformed program (<see cref="ArgumentException"/>), since a
-        /// post could raise before the wrong move.
-        /// </summary>
-        public static bool[] RaisedMask(IReadOnlyList<ICode> codes)
-        {
-            ArgumentNullException.ThrowIfNull(codes);
-            var mask = new bool[codes.Count];
-            for (var i = 0; i < codes.Count; i++)
-            {
-                if (!IsMarker(codes[i]))
-                    continue;
-                if (i + 1 >= codes.Count || codes[i + 1] is not (RapidMove or SubProgramCall))
-                    throw new ArgumentException("A head-raise marker is not followed by a rapid.");
-                mask[i + 1] = true;
-            }
-            return mask;
-        }
-
-        /// <summary>
-        /// A copy of <paramref name="program"/> with a marker before each of its own codes at
-        /// <paramref name="rapids"/>, which must be rapids or sub-program calls not marked already.
-        /// </summary>
-        public static Program Mark(Program program, IReadOnlyCollection<int> rapids)
-        {
-            ArgumentNullException.ThrowIfNull(program);
-            ArgumentNullException.ThrowIfNull(rapids);
-            var marked = RaisedMask(program.Codes);
-            var copy = (Program)program.Clone();
-            for (var i = copy.Codes.Count - 1; i >= 0; i--)
-            {
-                if (!rapids.Contains(i))
-                    continue;
-                if (copy.Codes[i] is not (RapidMove or SubProgramCall) || marked[i])
-                    throw new ArgumentException("Only an unmarked rapid or sub-program call can be marked for a head raise.");
-                copy.Codes.Insert(i, new Comment(Marker));
-            }
-            return copy;
-        }
-
-        /// <summary>
-        /// Refuses a nest a post cannot write, before any output is created: a marked rapid needs
-        /// the post's head-raise code, and its markers must be well formed.
-        /// </summary>
-        public static void EnsurePostable(Nest nest, bool hasCode, string postName) =>
-            PostMarkers.EnsurePostable(nest, hasCode, IsMarked, program => RaisedMask(program.Codes),
-                name => $"{name} has rapids that must raise the head over parts already cut, but "
-                    + $"the {postName} post has no head-raise code. Enter it in \"Head raise\" in "
-                    + $"the {postName} Settings dialog, which opens when you post.");
-    }
-}

OpenNest.Core/CNC/LayerType.cs

@@ -30,13 +30,5 @@ namespace OpenNest.CNC
         /// closed contour enclosing every other contour.
         /// </summary>
         DisplayPerimeter,
-
-        /// <summary>
-        /// A shared cut of a common-line group (see docs/common-line-cutting.md): an open cut on the
-        /// centerline between two parts placed one kerf apart, which cuts both parts' facing edges
-        /// at once. It is cut without kerf compensation, bounds no material and is never a rapid
-        /// obstacle. Posts that cannot write it refuse the nest.
-        /// </summary>
-        CommonLine,
     }
 }

OpenNest.Core/CNC/PostMarkers.cs

@@ -1,37 +0,0 @@
-using System;
-
-namespace OpenNest.CNC
-{
-    internal static class PostMarkers
-    {
-        /// <summary>
-        /// Refuses a nest whose marked programs a post cannot write: every marked part needs the
-        /// post's <paramref name="hasCode"/>, and <paramref name="validate"/> rejects a malformed
-        /// program with an <see cref="ArgumentException"/>.
-        /// </summary>
-        public static void EnsurePostable(Nest nest, bool hasCode, Func<Program, bool> isMarked,
-            Action<Program> validate, Func<string, string> missingCode)
-        {
-            ArgumentNullException.ThrowIfNull(nest);
-            foreach (var plate in nest.Plates)
-            {
-                foreach (var part in plate.Parts)
-                {
-                    if (part?.Program == null || !isMarked(part.Program))
-                        continue;
-                    var name = DisplayPerimeterTail.PartName(part);
-                    if (!hasCode)
-                        throw new InvalidOperationException(missingCode(name));
-                    try
-                    {
-                        validate(part.Program);
-                    }
-                    catch (ArgumentException ex)
-                    {
-                        throw new InvalidOperationException($"{name} cannot be posted: {ex.Message}", ex);
-                    }
-                }
-            }
-        }
-    }
-}

OpenNest.Core/CNC/Posting/ContourWinding.cs

@@ -1,164 +0,0 @@
-using System.Collections.Generic;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.CNC.Posting;
-
-/// <summary>
-/// Which posted contour is the perimeter, and which compensation side keeps the kerf in the
-/// scrap. Imported drawings are wound perimeter CW and holes CCW
-/// (<see cref="ShapeProfile.NormalizeWinding"/>), which puts the part right of travel and gives
-/// G41 throughout; a contour wound the other way (built in code or edited by hand) needs G42.
-/// Paths that enclose no area (open break cuts) get G41, a defensive default.
-/// </summary>
-public static class ContourWinding
-{
-    /// <summary>Signed shoelace area of the cut path; negative when clockwise, 0 when degenerate.</summary>
-    public static double SignedArea(PostContour contour)
-    {
-        var pts = SamplePoints(contour);
-        if (pts.Count < 3)
-            return 0.0;
-
-        var sum = 0.0;
-        for (var i = 0; i < pts.Count; i++)
-        {
-            var a = pts[i];
-            var b = pts[(i + 1) % pts.Count];
-            sum += a.X * b.Y - b.X * a.Y;
-        }
-
-        return sum / 2.0;
-    }
-
-    /// <summary>
-    /// Index of the perimeter: the material contour enclosing the largest bounding box, as
-    /// <see cref="ShapeProfile"/> picks it. -1 when none encloses any area.
-    /// </summary>
-    public static int PerimeterIndex(IReadOnlyList<PostContour> contours)
-    {
-        var best = -1;
-        var bestArea = 0.0;
-        for (var i = 0; i < contours.Count; i++)
-        {
-            if (contours[i].IsMark || !EnclosesArea(contours[i]))
-                continue;
-
-            var area = BoundingBoxArea(SamplePoints(contours[i]));
-            if (best < 0 || area > bestArea)
-            {
-                best = i;
-                bestArea = area;
-            }
-        }
-
-        return best;
-    }
-
-    /// <summary>
-    /// <see cref="KerfType.Left"/> (G41, part right of travel) for a CW perimeter, a CCW hole or
-    /// a path enclosing no area; otherwise <see cref="KerfType.Right"/> (G42).
-    /// </summary>
-    public static KerfType CompensationSide(PostContour contour, bool isPerimeter)
-    {
-        if (!EnclosesArea(contour))
-            return KerfType.Left;
-
-        var clockwise = SignedArea(contour) < 0.0;
-        return clockwise == isPerimeter ? KerfType.Left : KerfType.Right;
-    }
-
-    private static bool EnclosesArea(PostContour contour) =>
-        System.Math.Abs(SignedArea(contour)) > 1e-9;
-
-    private static double BoundingBoxArea(List<Vector> pts)
-    {
-        double minX = double.MaxValue, minY = double.MaxValue;
-        double maxX = double.MinValue, maxY = double.MinValue;
-        foreach (var p in pts)
-        {
-            minX = System.Math.Min(minX, p.X);
-            minY = System.Math.Min(minY, p.Y);
-            maxX = System.Math.Max(maxX, p.X);
-            maxY = System.Math.Max(maxY, p.Y);
-        }
-
-        return (maxX - minX) * (maxY - minY);
-    }
-
-    /// <summary>
-    /// Ordered points along the path: the contour start, then each cut endpoint, with arc
-    /// interior samples at no more than 90-degree steps so full circles give a well-formed
-    /// polygon. Consecutive duplicates are dropped so zero-length lead-ins do not skew it.
-    /// </summary>
-    private static List<Vector> SamplePoints(PostContour contour)
-    {
-        var pts = new List<Vector>();
-
-        void Add(Vector v)
-        {
-            if (pts.Count == 0 || pts[^1].DistanceTo(v) > 1e-9)
-                pts.Add(v);
-        }
-
-        var prev = contour.LeadIn != null ? contour.LeadIn.EndPoint : contour.Pierce;
-        Add(prev);
-
-        foreach (var cut in contour.Cuts)
-        {
-            if (cut is ArcMove arc)
-            {
-                foreach (var mid in ArcSamplePoints(prev, arc))
-                    Add(mid);
-            }
-            Add(cut.EndPoint);
-            prev = cut.EndPoint;
-        }
-
-        return pts;
-    }
-
-    /// <summary>
-    /// Interior points on the arc from <paramref name="prev"/> to its endpoint at no more than
-    /// ~90-degree steps. A full circle yields four, so its shoelace sign is its true winding.
-    /// </summary>
-    private static List<Vector> ArcSamplePoints(Vector prev, ArcMove arc)
-    {
-        var points = new List<Vector>();
-        var center = arc.CenterPoint;
-        var radius = center.DistanceTo(arc.EndPoint);
-        if (radius < 1e-12)
-            return points;
-
-        var a0 = PortableMath.Atan2(prev.Y - center.Y, prev.X - center.X);
-        var a1 = PortableMath.Atan2(arc.EndPoint.Y - center.Y, arc.EndPoint.X - center.X);
-
-        var sweep = arc.Rotation == RotationType.CW ? a0 - a1 : a1 - a0;
-        if (sweep <= 0)
-            sweep += 2.0 * System.Math.PI;
-
-        // Full circle (start == end) reads as zero sweep above.
-        if (
-            sweep < 1e-9
-            && System.Math.Abs(prev.X - arc.EndPoint.X) < 1e-9
-            && System.Math.Abs(prev.Y - arc.EndPoint.Y) < 1e-9
-        )
-            sweep = 2.0 * System.Math.PI;
-
-        var direction = arc.Rotation == RotationType.CW ? -1.0 : 1.0;
-        var steps = System.Math.Max(1, (int)System.Math.Ceiling(sweep / (System.Math.PI / 2.0)));
-
-        for (var k = 1; k <= steps; k++)
-        {
-            var angle = a0 + direction * sweep * k / (steps + 1);
-            points.Add(
-                new Vector(
-                    center.X + radius * PortableMath.Cos(angle),
-                    center.Y + radius * PortableMath.Sin(angle)
-                )
-            );
-        }
-
-        return points;
-    }
-}

OpenNest.Core/CNC/Posting/PostContour.cs

@@ -1,79 +0,0 @@
-using System.Collections.Generic;
-using OpenNest.Geometry;
-
-namespace OpenNest.CNC.Posting;
-
-/// <summary>
-/// One contour of a posted part: pierce, lead-in and cut path in a single absolute frame
-/// (sheet coordinates from <see cref="PostContours.Extract(Part)"/>). Arc moves keep their
-/// absolute centres; each post formats I/J its own way.
-/// </summary>
-public sealed class PostContour
-{
-    /// <summary>Pierce point: the rapid target.</summary>
-    public Vector Pierce { get; set; }
-
-    /// <summary>
-    /// First lead-in move, ending on the contour, or null when the contour starts cutting at
-    /// the pierce.
-    /// </summary>
-    public Motion LeadIn { get; set; }
-
-    /// <summary>Lead-in moves after the first (e.g. the arc after a clean-hole line).</summary>
-    public List<Motion> LeadInExtra { get; } = new();
-
-    /// <summary>Moves made with the cut layer on: cut, lead-out, display and scribe.</summary>
-    public List<Motion> Cuts { get; } = new();
-
-    /// <summary>
-    /// Head-height lock changes in a cut-off's overcut: each comes before the cut at
-    /// <c>Before</c> (<see cref="Cuts"/>.Count: after the last cut), locking when <c>Lock</c>.
-    /// </summary>
-    public List<(int Before, bool Lock)> HeadLocks { get; } = new();
-
-    /// <summary>Whether the rapid to the pierce raises the head over parts already cut (<see cref="HeadRaise"/>).</summary>
-    public bool Raised { get; set; }
-
-    /// <summary>
-    /// True for a common line's shared cut (<see cref="LayerType.CommonLine"/>): an open
-    /// centerline cut made without kerf compensation.
-    /// </summary>
-    public bool IsCommonLine { get; set; }
-
-    /// <summary>
-    /// For a common-line remainder, the winding of the perimeter it belongs to
-    /// (<see cref="CommonLineCuts"/>): it is cut as the perimeter, compensated on that side.
-    /// Null for every other contour.
-    /// </summary>
-    public RotationType? RemainderWinding { get; set; }
-
-    /// <summary>
-    /// True for the part's outside edge, or a common-line remainder of it; false for holes,
-    /// marks, shared cuts and cut-offs.
-    /// </summary>
-    public bool IsPerimeter { get; set; }
-
-    /// <summary>
-    /// The compensation that keeps the kerf in the scrap: <see cref="KerfType.Left"/> (G41)
-    /// leaves the part right of travel, <see cref="KerfType.Right"/> (G42) left of it.
-    /// <see cref="KerfType.None"/> for marks, common-line shared cuts and cut-offs, which have
-    /// no inside.
-    /// </summary>
-    public KerfType Kerf { get; set; }
-
-    /// <summary>True when every cut is on the scribe layer: a mark, not material.</summary>
-    public bool IsMark
-    {
-        get
-        {
-            if (Cuts.Count == 0)
-                return false;
-            foreach (var cut in Cuts)
-            {
-                if (PostContours.LayerOf(cut) != LayerType.Scribe)
-                    return false;
-            }
-            return true;
-        }
-    }
-}

OpenNest.Core/CNC/Posting/PostContours.cs

@@ -1,217 +0,0 @@
-using System;
-using System.Collections.Generic;
-using OpenNest.Geometry;
-
-namespace OpenNest.CNC.Posting;
-
-/// <summary>
-/// Reduces a part program to the contours a post writes: hole calls and incremental programs
-/// flattened to one absolute frame, each contour split into pierce, lead-in and cuts, the
-/// perimeter picked out and the kerf side chosen. Posts format these; they do not redo the
-/// geometry. Caller programs are never modified.
-/// </summary>
-public static class PostContours
-{
-    /// <summary>
-    /// The part's contours in sheet coordinates. A display perimeter's tail is never cut and an
-    /// unplanned one is refused (<see cref="DisplayPerimeterTail.ForPosting"/>). Cut-off contours
-    /// are open lines on the beam centreline: no perimeter and no kerf.
-    /// </summary>
-    public static List<PostContour> Extract(Part part)
-    {
-        if (part == null)
-            throw new ArgumentNullException(nameof(part));
-
-        var program = DisplayPerimeterTail.ForPosting(part.Program, DisplayPerimeterTail.PartName(part));
-        var contours = Extract(program, part.Location);
-        if (part.BaseDrawing?.IsCutOff == true)
-        {
-            foreach (var contour in contours)
-            {
-                contour.IsPerimeter = false;
-                contour.Kerf = KerfType.None;
-            }
-        }
-        return contours;
-    }
-
-    /// <summary>
-    /// The program's contours with <paramref name="origin"/> added to every point: the part
-    /// location for sheet coordinates, <see cref="Vector.Zero"/> for the part's own frame.
-    /// </summary>
-    public static List<PostContour> Extract(Program program, Vector origin)
-    {
-        var contours = Flatten(program, origin);
-        Classify(contours);
-        return contours;
-    }
-
-    /// <summary>
-    /// The program's contours in the <paramref name="origin"/> frame, with no perimeter or kerf
-    /// side chosen yet. A post that splits one part across several calls gathers them here and
-    /// classifies the whole part with <see cref="Classify"/>.
-    /// </summary>
-    public static List<PostContour> Flatten(Program program, Vector origin)
-    {
-        var contours = new List<PostContour>();
-        FlattenInto(program, origin, contours);
-        return contours;
-    }
-
-    /// <summary>
-    /// Picks one part's perimeter (marks excluded) and each contour's kerf side. A common-line
-    /// member's outside is its remainders, each compensated on its perimeter's side, so its
-    /// closed contours are all holes; a shared cut has no kerf side.
-    /// </summary>
-    public static void Classify(IReadOnlyList<PostContour> contours)
-    {
-        var remainders = false;
-        foreach (var contour in contours)
-            remainders |= contour.RemainderWinding != null;
-
-        var perimeter = remainders ? -1 : ContourWinding.PerimeterIndex(contours);
-        for (var i = 0; i < contours.Count; i++)
-        {
-            var contour = contours[i];
-            if (contour.RemainderWinding is { } winding)
-            {
-                // G41 leaves the product right of travel: a clockwise perimeter's side.
-                contour.IsPerimeter = true;
-                contour.Kerf = winding == RotationType.CW ? KerfType.Left : KerfType.Right;
-                continue;
-            }
-
-            contour.IsPerimeter = i == perimeter;
-            contour.Kerf = contour.IsMark || contour.IsCommonLine
-                ? KerfType.None
-                : ContourWinding.CompensationSide(contour, contour.IsPerimeter);
-        }
-    }
-
-    /// <summary>
-    /// Walks one program whose coordinates are relative to <paramref name="origin"/>; hole calls
-    /// recurse with their offset added. A contour starts at each rapid. Moves before the first
-    /// rapid start at the frame origin, where an absolute program begins. A cut after a run of
-    /// suppressed moves starts a new contour pierced where the run ends, so the gap is crossed
-    /// with the beam off rather than cut as a chord. A head-raise marker raises the head for
-    /// the next contour's rapid; <paramref name="raiseFirst"/> carries a marker before the hole
-    /// call that runs this program.
-    /// </summary>
-    private static void FlattenInto(Program program, Vector origin, List<PostContour> contours,
-        bool raiseFirst = false)
-    {
-        if (program == null)
-            return;
-
-        var codes = program.Codes;
-        if (program.Mode == Mode.Incremental)
-        {
-            var clone = (Program)program.Clone();
-            clone.Mode = Mode.Absolute;
-            codes = clone.Codes;
-        }
-
-        PostContour current = null;
-        Vector? resumeAt = null;
-        var raise = raiseFirst;
-
-        PostContour Start(Vector pierce)
-        {
-            var contour = new PostContour { Pierce = pierce, Raised = raise };
-            raise = false;
-            return contour;
-        }
-
-        void Flush()
-        {
-            if (current != null && (current.LeadIn != null || current.Cuts.Count > 0))
-                contours.Add(current);
-            current = null;
-        }
-
-        foreach (var code in codes)
-        {
-            if (code is Motion { Suppressed: true } suppressed)
-            {
-                resumeAt = suppressed.EndPoint;
-                continue;
-            }
-
-            if (HeadRaise.IsMarker(code))
-            {
-                raise = true;
-                continue;
-            }
-
-            if (CommonLineCuts.RemainderWinding(code) is { } winding)
-            {
-                current ??= Start(origin);
-                current.RemainderWinding = winding;
-                continue;
-            }
-
-            if (HeadHeightLock.IsLock(code) || HeadHeightLock.IsUnlock(code))
-            {
-                current ??= Start(origin);
-                current.HeadLocks.Add((current.Cuts.Count, HeadHeightLock.IsLock(code)));
-                continue;
-            }
-
-            switch (code)
-            {
-                case RapidMove rapid:
-                    Flush();
-                    resumeAt = null;
-                    current = Start(rapid.EndPoint + origin);
-                    break;
-
-                case SubProgramCall call:
-                    // A hole call is its own contour.
-                    Flush();
-                    resumeAt = null;
-                    FlattenInto(call.Program, origin + call.Offset, contours, raise);
-                    raise = false;
-                    break;
-
-                case Motion motion:
-                    if (resumeAt.HasValue)
-                    {
-                        Flush();
-                        current = Start(resumeAt.Value + origin);
-                        resumeAt = null;
-                    }
-                    current ??= Start(origin);
-
-                    var absolute = (Motion)motion.Clone();
-                    absolute.Offset(origin);
-
-                    var layer = LayerOf(motion);
-                    if (layer == LayerType.Leadin)
-                    {
-                        if (current.LeadIn == null)
-                            current.LeadIn = absolute;
-                        else
-                            current.LeadInExtra.Add(absolute);
-                    }
-                    else
-                    {
-                        // Contour moves are tagged Display by default and still cut.
-                        current.Cuts.Add(absolute);
-                        if (layer == LayerType.CommonLine)
-                            current.IsCommonLine = true;
-                    }
-                    break;
-            }
-        }
-
-        Flush();
-    }
-
-    internal static LayerType LayerOf(Motion motion) =>
-        motion switch
-        {
-            LinearMove linear => linear.Layer,
-            ArcMove arc => arc.Layer,
-            _ => LayerType.Cut,
-        };
-}

OpenNest.Core/CNC/Program.cs

@@ -37,16 +37,6 @@ namespace OpenNest.CNC
 
         public double Rotation { get; protected set; }
 
-        /// <summary>
-        /// True once <see cref="Part.CloneAtOffset"/> has handed this instance to a second
-        /// part. A part must copy a shared program before changing it in place, whether or not
-        /// it owns it. Never cleared: the parts sharing it are not tracked, so a program that
-        /// was shared once is treated as shared for good, at the cost of one copy. It belongs
-        /// to the instance, not its content: <see cref="Clone"/> and <see cref="HeadCopy"/>
-        /// build a new program and leave it unset.
-        /// </summary>
-        internal bool SharedByParts { get; set; }
-
         private void SetModeInc()
         {
             if (mode == Mode.Incremental)
@@ -113,8 +103,8 @@ namespace OpenNest.CNC
 
                     if (subpgm.Offset.X != 0 || subpgm.Offset.Y != 0)
                     {
-                        var cos = PortableMath.Cos(angle);
+                        var cos = System.Math.Cos(angle);
-                        var sin = PortableMath.Sin(angle);
+                        var sin = System.Math.Sin(angle);
                         var dx = subpgm.Offset.X - origin.X;
                         var dy = subpgm.Offset.Y - origin.Y;
                         subpgm.Offset = new Geometry.Vector(
@@ -168,7 +158,35 @@ namespace OpenNest.CNC
                 SetModeInc();
         }
 
-        public virtual void Offset(Vector voffset) => Offset(voffset.X, voffset.Y);
+        public virtual void Offset(Vector voffset)
+        {
+            var mode = Mode;
+
+            SetModeAbs();
+
+            for (int i = 0; i < Codes.Count; ++i)
+            {
+                var code = Codes[i];
+
+                if (code is SubProgramCall subpgm)
+                {
+                    subpgm.Offset = new Geometry.Vector(
+                        subpgm.Offset.X + voffset.X,
+                        subpgm.Offset.Y + voffset.Y
+                    );
+                }
+
+                if (code is Motion == false)
+                    continue;
+
+                var code2 = (Motion)code;
+
+                code2.Offset(voffset);
+            }
+
+            if (mode == Mode.Incremental)
+                SetModeInc();
+        }
 
         public void LineTo(double x, double y)
         {

OpenNest.Core/CanonicalAngle.cs

@@ -1,7 +1,6 @@
 using System.Linq;
 using OpenNest.Converters;
 using OpenNest.Geometry;
-using OpenNest.Math;
 
 namespace OpenNest
 {
@@ -124,7 +123,7 @@ namespace OpenNest
             // keeps offsets lying exactly on an axis (mirror-symmetric parts) away from the
             // interval edge so floating-point noise cannot flip the choice.
             var halfPi = System.Math.PI / 2.0;
-            var direction = PortableMath.Atan2(dy, dx);
+            var direction = System.Math.Atan2(dy, dx);
             for (var turns = 0; turns < 4; turns++)
             {
                 var relative = direction + turns * halfPi - (System.Math.PI - PreferenceMargin);

OpenNest.Core/ClampEdge.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace OpenNest.Clamps
+namespace OpenNest
 {
     /// <summary>
     /// The sheet edge a <see cref="ClampRail"/> clamp sits on, named relative to the plate

OpenNest.Core/ClampRail.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using OpenNest.Geometry;
 
-namespace OpenNest.Clamps
+namespace OpenNest
 {
     /// <summary>
     /// The machine's fixed clamp rail: identical rectangular clamps, each on one sheet edge
@@ -26,16 +26,14 @@ namespace OpenNest.Clamps
             double width,
             double depth,
             IEnumerable<double> centers,
-            double removalMinutes = DefaultRemovalMinutes,
+            double removalMinutes = DefaultRemovalMinutes
-            double? clearance = null
         )
             : this(
                 width,
                 depth,
                 (centers ?? throw new ArgumentNullException(nameof(centers)))
                     .Select(c => new RailClamp(ClampEdge.OriginSide, c)),
-                removalMinutes,
+                removalMinutes
-                clearance
             )
         { }
 
@@ -43,8 +41,7 @@ namespace OpenNest.Clamps
             double width,
             double depth,
             IEnumerable<RailClamp> clamps,
-            double removalMinutes = DefaultRemovalMinutes,
+            double removalMinutes = DefaultRemovalMinutes
-            double? clearance = null
         )
         {
             ArgumentNullException.ThrowIfNull(clamps);
@@ -63,11 +60,6 @@ namespace OpenNest.Clamps
                     nameof(removalMinutes),
                     "Clamp removal time must be finite and zero or more."
                 );
-            if (clearance is double c && (!double.IsFinite(c) || c < 0))
-                throw new ArgumentOutOfRangeException(
-                    nameof(clearance),
-                    "Clamp clearance must be finite and zero or more."
-                );
 
             var sorted = new SortedSet<RailClamp>();
             foreach (var clamp in clamps)
@@ -85,7 +77,6 @@ namespace OpenNest.Clamps
             Width = width;
             Depth = depth;
             RemovalMinutes = removalMinutes;
-            Clearance = clearance;
             Clamps = sorted.ToArray();
             Centers = Clamps.Where(c => c.Edge == ClampEdge.OriginSide).Select(c => c.Center).ToArray();
         }
@@ -102,14 +93,6 @@ namespace OpenNest.Clamps
         /// </summary>
         public double RemovalMinutes { get; }
 
-        /// <summary>
-        /// The gap parts keep from every clamp footprint, independent of part spacing; null
-        /// keeps the sheet's bottom edge spacing (D6), the clearance before clamps had their
-        /// own. A clamp drawn as a support block under the sheet can use close to zero, so the
-        /// laser only stays off it. See <see cref="Plate.ClampClearance"/>.
-        /// </summary>
-        public double? Clearance { get; }
-
         /// <summary>
         /// Distinct clamps ordered by edge, then center. A clamp's position in this list
         /// gives its <c>clamp-N</c> id, so a rail with only origin-side clamps keeps the ids
@@ -120,9 +103,9 @@ namespace OpenNest.Clamps
         /// <summary>Centers of the origin-side clamps, ascending; see <see cref="Clamps"/> for all.</summary>
         public IReadOnlyList<double> Centers { get; }
 
-        /// <summary>A copy with the same size, removal time and clearance and these clamps.</summary>
+        /// <summary>A copy with the same size and removal time and these clamps.</summary>
         public ClampRail WithClamps(IEnumerable<RailClamp> clamps) =>
-            new(Width, Depth, clamps, RemovalMinutes, Clearance);
+            new(Width, Depth, clamps, RemovalMinutes);
 
         /// <summary>The <c>clamp-N</c> id of the clamp at <paramref name="index"/> in <see cref="Clamps"/>.</summary>
         public static string IdOf(int index) => $"clamp-{index + 1}";
@@ -242,22 +225,20 @@ namespace OpenNest.Clamps
             && Width.Equals(other.Width)
             && Depth.Equals(other.Depth)
             && RemovalMinutes.Equals(other.RemovalMinutes)
-            && Nullable.Equals(Clearance, other.Clearance)
             && Clamps.SequenceEqual(other.Clamps);
 
         public override bool Equals(object obj) => Equals(obj as ClampRail);
 
         public override int GetHashCode()
         {
-            var hash = HashCode.Combine(Width, Depth, RemovalMinutes, Clearance, Clamps.Count);
+            var hash = HashCode.Combine(Width, Depth, RemovalMinutes, Clamps.Count);
             foreach (var clamp in Clamps)
                 hash = HashCode.Combine(hash, clamp);
             return hash;
         }
 
         public override string ToString() =>
-            $"ClampRail {Width:R} x {Depth:R} at [{string.Join(", ", Clamps.Select(Describe))}]"
+            $"ClampRail {Width:R} x {Depth:R} at [{string.Join(", ", Clamps.Select(Describe))}]";
-            + (Clearance is double clearance ? $" clearance {clearance:R}" : "");
 
         private static string Describe(RailClamp clamp) =>
             clamp.Edge == ClampEdge.OriginSide

OpenNest.Core/ClampZone.cs

@@ -1,7 +1,7 @@
 using System;
 using OpenNest.Geometry;
 
-namespace OpenNest.Clamps
+namespace OpenNest
 {
     /// <summary>
     /// A fixed rectangular keep-out region in plate coordinates (the sheet's own frame:

OpenNest.Core/ClampZoneFrame.cs

@@ -2,7 +2,7 @@ using System;
 using System.Collections.Generic;
 using OpenNest.Geometry;
 
-namespace OpenNest.Clamps;
+namespace OpenNest;
 
 /// <summary>
 /// Maps a plate's <see cref="Plate.ClampZones"/>, stored in the sheet's lower-left frame

OpenNest.Core/CommonLines/CommonLineCutting.cs

@@ -1,323 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.CNC;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.CommonLines
-{
-    /// <summary>
-    /// One shared cut of a common-line group: a straight span, or spans chained at corners (a Z or
-    /// L shared line). <see cref="Owner"/>, the member of the pair cut first, cuts it as part of its
-    /// own compensated perimeter, which lands on the kerf centerline. <see cref="Partner"/> is cut
-    /// later; its remainder ends in the kerf this cut opened.
-    /// </summary>
-    public sealed record CommonLineSharedCut(CommonLinePath Path, Part Owner, Part Partner);
-
-    /// <summary>
-    /// How a common-line group is cut once (see docs/common-line-cutting.md): its members in cutting
-    /// order, and each shared cut with the member that cuts it.
-    /// </summary>
-    public sealed record CommonLineCutOrder(CommonLineGroup Group, IReadOnlyList<Part> Members,
-        IReadOnlyList<CommonLineSharedCut> Cuts)
-    {
-        /// <summary>The shared cuts <paramref name="member"/> cuts.</summary>
-        public IEnumerable<CommonLineSharedCut> CutsOwnedBy(Part member) =>
-            Cuts.Where(cut => ReferenceEquals(cut.Owner, member));
-
-        /// <summary>
-        /// The shared paths an earlier member cuts and <paramref name="member"/> therefore never
-        /// does: its remainder ends in their kerf.
-        /// </summary>
-        public IEnumerable<CommonLinePath> PathsCutBefore(Part member) => Cuts
-            .Where(cut => ReferenceEquals(cut.Partner, member))
-            .Select(cut => cut.Path);
-
-        /// <summary>Every shared path <paramref name="member"/> shares, whoever cuts it.</summary>
-        public IEnumerable<CommonLinePath> PathsOf(Part member) => Cuts
-            .Where(cut => ReferenceEquals(cut.Owner, member) || ReferenceEquals(cut.Partner, member))
-            .Select(cut => cut.Path);
-    }
-
-    /// <summary>
-    /// Single-pass common-line cutting: which member cuts each shared span, and the planner's owned
-    /// clean perimeter with its shared spans marked as never cut by that member.
-    /// </summary>
-    public static class CommonLineCutting
-    {
-        /// <summary>
-        /// The cutting order of an intact group: members breadth-first from its first member along
-        /// shared spans (ties in member order), each shared cut owned by the member cut first. A
-        /// member's remainder therefore only ever ends in kerf cut before it.
-        /// </summary>
-        /// <exception cref="ArgumentException">The group is not intact.</exception>
-        public static CommonLineCutOrder Order(CommonLineGroup group, CommonLineCheck check)
-        {
-            ArgumentNullException.ThrowIfNull(group);
-            ArgumentNullException.ThrowIfNull(check);
-            if (!check.IsIntact)
-                throw new ArgumentException(check.Problems[0].Message, nameof(check));
-            var members = group.Members;
-            int IndexOf(Part part) => members.ToList().FindIndex(member => ReferenceEquals(member, part));
-            var order = new List<Part>();
-            var seen = new bool[members.Count];
-            var queue = new Queue<int>();
-            queue.Enqueue(0);
-            seen[0] = true;
-            while (queue.Count > 0)
-            {
-                var current = members[queue.Dequeue()];
-                order.Add(current);
-                var neighbors = check.Spans
-                    .Select(span => ReferenceEquals(span.First, current) ? span.Second
-                        : ReferenceEquals(span.Second, current) ? span.First : null)
-                    .Where(part => part != null)
-                    .Select(IndexOf)
-                    .Distinct()
-                    .Order();
-                foreach (var next in neighbors)
-                    if (!seen[next])
-                    {
-                        seen[next] = true;
-                        queue.Enqueue(next);
-                    }
-            }
-            if (order.Count != members.Count)
-                throw new ArgumentException("The common-line group has split into separate pieces.", nameof(check));
-            int Rank(Part part) => order.FindIndex(member => ReferenceEquals(member, part));
-            var cuts = CommonLineGeometry.Paths(check.Spans, group.Kerf)
-                .Select(path => Rank(path.First) < Rank(path.Second)
-                    ? new CommonLineSharedCut(path, path.First, path.Second)
-                    : new CommonLineSharedCut(path, path.Second, path.First))
-                .OrderBy(cut => Rank(cut.Owner))
-                .ToList();
-            return new CommonLineCutOrder(group, order, cuts);
-        }
-
-        /// <summary>
-        /// <see cref="MarkSharedSpans(Program, Vector, IReadOnlyList{CommonLinePath}, double)"/> with
-        /// every span a straight path of its own.
-        /// </summary>
-        public static Program MarkSharedSpans(Program clean, Vector location, IReadOnlyList<CommonLineSpan> spans,
-            double kerf)
-        {
-            ArgumentNullException.ThrowIfNull(spans);
-            return MarkSharedSpans(clean, location, spans
-                .Select(span => new CommonLinePath(span.First, span.Second, [span], [span.Start, span.End]))
-                .ToArray(), kerf);
-        }
-
-        /// <summary>
-        /// A copy of <paramref name="clean"/> (a member's clean program, rotated as placed, in part
-        /// coordinates; placed at <paramref name="location"/>) whose perimeter edges are split at
-        /// every end of the shared <paramref name="paths"/> and whose shared portions are on the
-        /// <see cref="LayerType.Tab"/> layer: material that this member never cuts, because the
-        /// shared cut does. At a path's corner each leg's portion runs to the member's own vertex
-        /// there, so the legs' portions join. The result is absolute. Only straight top-level
-        /// moves can share.
-        /// </summary>
-        /// <exception cref="ArgumentException">A path's leg does not lie along the program's edges.</exception>
-        public static Program MarkSharedSpans(Program clean, Vector location, IReadOnlyList<CommonLinePath> paths,
-            double kerf)
-        {
-            ArgumentNullException.ThrowIfNull(clean);
-            ArgumentNullException.ThrowIfNull(paths);
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                throw new ArgumentOutOfRangeException(nameof(kerf));
-            var program = (Program)clean.Clone();
-            program.Mode = Mode.Absolute;
-            var legs = paths.SelectMany(path => Legs(path, location, kerf)).ToArray();
-            var covered = new double[legs.Length];
-            var codes = new List<ICode>();
-            Vector? position = null;
-            foreach (var code in program.Codes)
-            {
-                if (code is LinearMove line && position is { } start
-                    && line.Layer is LayerType.Cut or LayerType.Display)
-                {
-                    codes.AddRange(Split(line, start, legs, covered, kerf));
-                    position = line.EndPoint;
-                    continue;
-                }
-                codes.Add(code);
-                position = code switch
-                {
-                    Motion motion => motion.EndPoint,
-                    SubProgramCall => null,
-                    _ => position,
-                };
-            }
-            for (var i = 0; i < legs.Length; i++)
-            {
-                var leg = legs[i];
-                // At a corner the member's portion ends at its own vertex, up to the snap off the centerline's.
-                var slack = leg.StartSnap + leg.EndSnap + CommonLineGeometry.GapTolerance;
-                if (covered[i] <= Math.Tolerance.Epsilon
-                    || System.Math.Abs(covered[i] - leg.Start.DistanceTo(leg.End)) > slack)
-                {
-                    var (a, b) = (leg.Start + location, leg.End + location);
-                    throw new ArgumentException(FormattableString.Invariant(
-                        $"The shared span from ({a.X:0.####}, {a.Y:0.####}) to ({b.X:0.####}, {b.Y:0.####}) does not lie along one straight edge of the part's program."));
-                }
-            }
-            program.Codes.Clear();
-            program.Codes.AddRange(codes);
-            return program;
-        }
-
-        /// <summary>
-        /// Where a member that cuts <paramref name="paths"/> as part of its own perimeter can start,
-        /// so that each common line leads straight into the rest of the perimeter: for each path,
-        /// the start of the perimeter edge (a top-level straight move of <paramref name="clean"/>)
-        /// along which the member's own travel enters the path, a pierce <paramref name="reach"/>
-        /// back along that edge's axis, and the edge's end. Part coordinates (the program placed at
-        /// <paramref name="location"/>), in path order.
-        /// </summary>
-        public static IReadOnlyList<(Vector Entry, Vector Pierce, Vector Next)> PerimeterEntries(Program clean,
-            Vector location, IReadOnlyList<CommonLinePath> paths, double kerf, double reach)
-        {
-            ArgumentNullException.ThrowIfNull(clean);
-            ArgumentNullException.ThrowIfNull(paths);
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                throw new ArgumentOutOfRangeException(nameof(kerf));
-            var program = (Program)clean.Clone();
-            program.Mode = Mode.Absolute;
-            var edges = new List<(Vector Start, Vector End)>();
-            Vector? position = null;
-            foreach (var code in program.Codes)
-            {
-                if (code is LinearMove line && position is { } from && line.Layer is LayerType.Cut or LayerType.Display)
-                    edges.Add((from, line.EndPoint));
-                position = code switch
-                {
-                    Motion motion => motion.EndPoint,
-                    SubProgramCall => null,
-                    _ => position,
-                };
-            }
-            var entries = new List<(Vector Entry, Vector Pierce, Vector Next)>();
-            foreach (var path in paths)
-            {
-                var points = path.Points.Select(point => point - location).ToArray();
-                // Each end of the path, with the direction into the path from there.
-                foreach (var (end, inward) in new[]
-                {
-                    (points[0], (points[1] - points[0]).Normalize()),
-                    (points[^1], (points[^2] - points[^1]).Normalize()),
-                })
-                    foreach (var (start, stop) in edges)
-                    {
-                        var length = start.DistanceTo(stop);
-                        if (length <= Math.Tolerance.Epsilon)
-                            continue;
-                        var along = new Vector((stop.X - start.X) / length, (stop.Y - start.Y) / length);
-                        if (System.Math.Abs(Cross(along, inward)) > 1e-6 || Dot(along, inward) <= 0)
-                            continue;
-                        if (System.Math.Abs(System.Math.Abs(Cross(along, end - start)) - kerf / 2) > CommonLineGeometry.GapTolerance)
-                            continue;
-                        var t = Dot(end - start, along);
-                        if (t < -CommonLineGeometry.GapTolerance || t > length + CommonLineGeometry.GapTolerance)
-                            continue;
-                        var entry = (start, start - along * reach, stop);
-                        if (!entries.Contains(entry))
-                            entries.Add(entry);
-                    }
-            }
-            return entries;
-        }
-
-        // One straight leg of a shared path in part coordinates. An end at a corner snaps to the
-        // edge's own vertex within kerf/2 · tan(turn/2) of the centerline corner's projection.
-        private readonly record struct Leg(Vector Start, Vector End, double StartSnap, double EndSnap);
-
-        private static IEnumerable<Leg> Legs(CommonLinePath path, Vector location, double kerf)
-        {
-            var points = path.Points.Select(point => point - location).ToArray();
-            var snaps = new double[points.Length];
-            for (var k = 1; k < points.Length - 1; k++)
-            {
-                var din = (points[k] - points[k - 1]).Normalize();
-                var dout = (points[k + 1] - points[k]).Normalize();
-                var turn = PortableMath.Atan2(System.Math.Abs(Cross(din, dout)), Dot(din, dout));
-                snaps[k] = kerf / 2 * PortableMath.Tan(turn / 2) + 2 * CommonLineGeometry.GapTolerance;
-            }
-            for (var k = 0; k + 1 < points.Length; k++)
-                yield return new Leg(points[k], points[k + 1], snaps[k], snaps[k + 1]);
-        }
-
-        // The line split where shared legs one half kerf off it begin and end; shared pieces on Tab.
-        private static IEnumerable<ICode> Split(LinearMove line, Vector start, Leg[] legs, double[] covered,
-            double kerf)
-        {
-            var end = line.EndPoint;
-            var length = start.DistanceTo(end);
-            if (length <= Math.Tolerance.Epsilon)
-                return [line];
-            var direction = new Vector((end.X - start.X) / length, (end.Y - start.Y) / length);
-            var intervals = new List<(double From, double To)>();
-            for (var i = 0; i < legs.Length; i++)
-            {
-                var (a, b, snapA, snapB) = legs[i];
-                var legLength = a.DistanceTo(b);
-                if (legLength <= Math.Tolerance.Epsilon)
-                    continue;
-                var along = new Vector((b.X - a.X) / legLength, (b.Y - a.Y) / legLength);
-                if (System.Math.Abs(Cross(direction, along)) > 1e-6)
-                    continue;
-                var offset = System.Math.Abs(Cross(direction, a - start));
-                if (System.Math.Abs(offset - kerf / 2) > CommonLineGeometry.GapTolerance)
-                    continue;
-                var ta = Snap(Dot(a - start, direction), snapA, length);
-                var tb = Snap(Dot(b - start, direction), snapB, length);
-                var from = System.Math.Max(0, System.Math.Min(ta, tb));
-                var to = System.Math.Min(length, System.Math.Max(ta, tb));
-                if (to - from <= Math.Tolerance.Epsilon)
-                    continue;
-                // An end within the snap tolerance of a vertex is that vertex: no sliver is left uncut.
-                if (from <= Math.Tolerance.Epsilon)
-                    from = 0;
-                if (length - to <= Math.Tolerance.Epsilon)
-                    to = length;
-                covered[i] += to - from;
-                intervals.Add((from, to));
-            }
-            if (intervals.Count == 0)
-                return [line];
-            var pieces = new List<ICode>();
-            var at = 0.0;
-            foreach (var (from, to) in intervals.OrderBy(interval => interval.From))
-            {
-                if (from < at - Math.Tolerance.Epsilon)
-                    throw new ArgumentException("Shared spans overlap along one edge.");
-                if (from - at > Math.Tolerance.Epsilon)
-                    pieces.Add(new LinearMove(Point(from)) { Layer = line.Layer });
-                pieces.Add(new LinearMove(to >= length ? end : Point(to)) { Layer = LayerType.Tab });
-                at = to;
-            }
-            if (length - at > Math.Tolerance.Epsilon)
-                pieces.Add(new LinearMove(end) { Layer = line.Layer });
-            else if (pieces[^1] is LinearMove last)
-                last.EndPoint = end;
-            return pieces;
-
-            Vector Point(double t) => new(start.X + direction.X * t, start.Y + direction.Y * t);
-        }
-
-        // A corner end within snap of either end of the edge is that end.
-        private static double Snap(double t, double snap, double length)
-        {
-            if (snap <= 0)
-                return t;
-            if (System.Math.Abs(t) <= snap)
-                return 0;
-            if (System.Math.Abs(t - length) <= snap)
-                return length;
-            return t;
-        }
-
-        private static double Dot(Vector a, Vector b) => a.X * b.X + a.Y * b.Y;
-
-        private static double Cross(Vector a, Vector b) => a.X * b.Y - a.Y * b.X;
-    }
-}

OpenNest.Core/CommonLines/CommonLineGeometry.cs

@@ -1,397 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.CNC;
-using OpenNest.Diagnostics;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.CommonLines
-{
-    /// <summary>One shared cut: the centerline between two parts' facing edges, one kerf apart.</summary>
-    public readonly record struct CommonLineSpan(Part First, Part Second, Vector Start, Vector End)
-    {
-        public double Length => Start.DistanceTo(End);
-    }
-
-    /// <summary>
-    /// One shared cut's path: the spans of one pair chained end to end at corners (a Z or L shared
-    /// line), or a single straight span. <see cref="Points"/> runs from the first span's free end
-    /// through each corner, where the spans' centerlines meet, to the last span's free end.
-    /// </summary>
-    public sealed record CommonLinePath(Part First, Part Second, IReadOnlyList<CommonLineSpan> Spans,
-        IReadOnlyList<Vector> Points)
-    {
-        public Vector Start => Points[0];
-
-        public Vector End => Points[^1];
-
-        /// <summary>The kerf-centerline length of the whole path, corners included.</summary>
-        public double Length
-        {
-            get
-            {
-                var length = 0.0;
-                for (var i = 1; i < Points.Count; i++)
-                    length += Points[i - 1].DistanceTo(Points[i]);
-                return length;
-            }
-        }
-    }
-
-    /// <summary>A member of a group that no longer shares a span, or could not be read.</summary>
-    public readonly record struct CommonLineProblem(Part Part, string Message);
-
-    /// <summary>Spans a group's members share now, and what breaks the group.</summary>
-    public sealed record CommonLineCheck(IReadOnlyList<CommonLineSpan> Spans, IReadOnlyList<CommonLineProblem> Problems)
-    {
-        public bool IsIntact => Problems.Count == 0;
-    }
-
-    /// <summary>
-    /// Derives common-line spans from placed parts' clean perimeters (leads excluded, holes never
-    /// share). Two straight perimeter edges share a span when they face each other (antiparallel,
-    /// outward normals opposed), lie one kerf apart within <see cref="GapTolerance"/> and overlap
-    /// along the line by at least <see cref="MinSharedLength"/>. Arcs never share.
-    /// </summary>
-    public static class CommonLineGeometry
-    {
-        /// <summary>How far a shared edge pair's gap may differ from the group's kerf (inches).</summary>
-        public const double GapTolerance = 0.0005;
-
-        /// <summary>The shortest overlap that counts as a shared span (inches).</summary>
-        public const double MinSharedLength = 0.25;
-
-        private const double ParallelTolerance = 1e-6;
-
-        /// <summary>A placed perimeter edge with its outward unit normal.</summary>
-        internal readonly record struct Edge(Vector Start, Vector End, Vector Direction, Vector Outward, double Length);
-
-        /// <summary>A facing edge pair: <see cref="Gap"/> along the first edge's outward normal,
-        /// the overlap as distances along the first edge from its start.</summary>
-        internal readonly record struct Facing(Edge First, Edge Second, double Gap, double From, double To)
-        {
-            public double Overlap => To - From;
-        }
-
-        /// <summary>The spans <paramref name="first"/> and <paramref name="second"/> share at <paramref name="kerf"/>.</summary>
-        public static IReadOnlyList<CommonLineSpan> Spans(Part first, Part second, double kerf)
-        {
-            ArgumentNullException.ThrowIfNull(first);
-            ArgumentNullException.ThrowIfNull(second);
-            var cache = new ProfileCache();
-            return Spans(first, Edges(first, cache), second, Edges(second, cache), kerf);
-        }
-
-        /// <summary>
-        /// Checks that every member of <paramref name="group"/> shares at least one span with another
-        /// member at the group's kerf, and that the members form one connected group.
-        /// </summary>
-        public static CommonLineCheck Check(CommonLineGroup group)
-        {
-            ArgumentNullException.ThrowIfNull(group);
-            var members = group.Members;
-            var cache = new ProfileCache();
-            var edges = new IReadOnlyList<Edge>[members.Count];
-            var problems = new List<CommonLineProblem>();
-            for (var i = 0; i < members.Count; i++)
-            {
-                try
-                {
-                    edges[i] = Edges(members[i], cache);
-                }
-                catch (Exception exception) when (IsInvalid(exception))
-                {
-                    problems.Add(new(members[i], $"could not be read ({exception.Message})."));
-                }
-            }
-            var spans = new List<CommonLineSpan>();
-            var links = members.Select(_ => new List<int>()).ToArray();
-            for (var i = 0; i < members.Count; i++)
-                for (var j = i + 1; j < members.Count; j++)
-                {
-                    if (edges[i] == null || edges[j] == null)
-                        continue;
-                    var shared = Spans(members[i], edges[i], members[j], edges[j], group.Kerf);
-                    if (shared.Count == 0)
-                        continue;
-                    spans.AddRange(shared);
-                    links[i].Add(j);
-                    links[j].Add(i);
-                }
-            for (var i = 0; i < members.Count; i++)
-                if (edges[i] != null && links[i].Count == 0)
-                    problems.Add(new(members[i],
-                        $"no longer shares a straight edge one kerf ({group.Kerf:0.####}) apart with another part in its common-line group."));
-            if (problems.Count == 0 && !Connected(links))
-                problems.Add(new(members[0], "its common-line group has split into separate pieces."));
-            return new CommonLineCheck(spans, problems);
-        }
-
-        /// <summary>
-        /// The move that puts <paramref name="moving"/> one kerf from <paramref name="anchor"/> along
-        /// their best facing edge pair: the longest overlap, then the smallest gap. Only pairs closer
-        /// than <paramref name="maxGap"/> (or already overlapping by up to that much) are considered;
-        /// null when there are none.
-        /// </summary>
-        public static Vector? JoinOffset(Part anchor, Part moving, double kerf, double maxGap)
-        {
-            ArgumentNullException.ThrowIfNull(anchor);
-            ArgumentNullException.ThrowIfNull(moving);
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                throw new ArgumentOutOfRangeException(nameof(kerf));
-            var cache = new ProfileCache();
-            var anchorEdges = Edges(anchor, cache);
-            var movingEdges = Edges(moving, cache);
-            var best = FacingEdges(anchorEdges, movingEdges, -maxGap, maxGap)
-                .OrderByDescending(facing => System.Math.Round(facing.Overlap, 6))
-                .ThenBy(facing => System.Math.Abs(facing.Gap - kerf))
-                .Cast<Facing?>()
-                .FirstOrDefault();
-            if (best is not { } chosen)
-                return null;
-            var shift = kerf - chosen.Gap;
-            var offset = new Vector(chosen.First.Outward.X * shift, chosen.First.Outward.Y * shift);
-            return Slide(anchorEdges, movingEdges, chosen, offset, kerf, maxGap) ?? offset;
-        }
-
-        // The offset slid along the chosen edge pair so that a facing pair across it (the step of a
-        // Z or L shared line) lands one kerf apart too, keeping the chosen pair's gap and span; null
-        // when no such pair is within reach.
-        private static Vector? Slide(IReadOnlyList<Edge> anchor, IReadOnlyList<Edge> moving, Facing chosen,
-            Vector offset, double kerf, double maxGap)
-        {
-            var along = chosen.First.Direction;
-            var minimum = PortableMath.Sin(MinCornerTurn);
-            var shifted = Shift(moving, offset);
-            var slides = FacingEdges(anchor, shifted, -maxGap, maxGap)
-                .Select(facing => (Facing: facing, Across: Dot(along, facing.First.Outward)))
-                .Where(choice => System.Math.Abs(choice.Across) >= minimum)
-                .Select(choice => (choice.Facing, Slide: (kerf - choice.Facing.Gap) / choice.Across))
-                .Where(choice => System.Math.Abs(choice.Slide) <= maxGap)
-                .OrderByDescending(choice => System.Math.Round(choice.Facing.Overlap, 6))
-                .ThenBy(choice => System.Math.Abs(choice.Slide));
-            foreach (var (_, slide) in slides)
-            {
-                var candidate = new Vector(offset.X + along.X * slide, offset.Y + along.Y * slide);
-                var placed = Shift(moving, candidate);
-                var spans = FacingEdges(anchor, placed, kerf - GapTolerance, kerf + GapTolerance).ToList();
-                // The chosen pair must still share, and the slid pair must now share across it.
-                if (spans.Any(facing => System.Math.Abs(Cross(facing.First.Direction, along)) <= ParallelTolerance)
-                    && spans.Any(facing => System.Math.Abs(Dot(along, facing.First.Outward)) >= minimum))
-                    return candidate;
-            }
-            return null;
-        }
-
-        private static IReadOnlyList<Edge> Shift(IReadOnlyList<Edge> edges, Vector offset) =>
-            edges.Select(edge => edge with { Start = edge.Start + offset, End = edge.End + offset }).ToArray();
-
-        /// <summary>The sharpest corner a shared path may turn (radians): 135°.</summary>
-        public const double MaxCornerTurn = 3 * System.Math.PI / 4;
-
-        /// <summary>The gentlest corner a shared path may turn (radians): 10°. Gentler meets are not corners.</summary>
-        public const double MinCornerTurn = System.Math.PI / 18;
-
-        /// <summary>
-        /// The shared cuts of <paramref name="spans"/> at <paramref name="kerf"/>: spans of one pair
-        /// whose ends meet at a corner (a Z or L shared line) chain into one path; every other span
-        /// is a path of its own. Two spans meet when their centerlines cross beyond both ends, each
-        /// end short of the crossing by what the kerf leaves there, <c>kerf/2 · tan(turn/2)</c>, and
-        /// the path turns between <see cref="MinCornerTurn"/> and <see cref="MaxCornerTurn"/>. Paths
-        /// keep the spans' order of first appearance.
-        /// </summary>
-        public static IReadOnlyList<CommonLinePath> Paths(IReadOnlyList<CommonLineSpan> spans, double kerf)
-        {
-            ArgumentNullException.ThrowIfNull(spans);
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                throw new ArgumentOutOfRangeException(nameof(kerf));
-            // links[i, end]: the span and end met at span i's end (0 = Start, 1 = End), and the corner.
-            var links = new (int Span, int End, Vector Corner)?[spans.Count, 2];
-            for (var i = 0; i < spans.Count; i++)
-                for (var j = i + 1; j < spans.Count; j++)
-                {
-                    if (!SamePair(spans[i], spans[j]))
-                        continue;
-                    for (var ei = 0; ei < 2; ei++)
-                        for (var ej = 0; ej < 2; ej++)
-                            if (links[i, ei] == null && links[j, ej] == null
-                                && Corner(spans[i], ei, spans[j], ej, kerf) is { } corner)
-                            {
-                                links[i, ei] = (j, ej, corner);
-                                links[j, ej] = (i, ei, corner);
-                            }
-                }
-            var used = new bool[spans.Count];
-            var paths = new List<CommonLinePath>();
-            for (var i = 0; i < spans.Count; i++)
-            {
-                if (used[i])
-                    continue;
-                // Walk back to a free end (or round a loop back to this span), then trace forward.
-                var (span, entry) = (i, links[i, 0] == null ? 0 : links[i, 1] == null ? 1 : 0);
-                for (var guard = 0; guard < spans.Count && links[span, entry] is { } back && back.Span != i; guard++)
-                    (span, entry) = (back.Span, 1 - back.End);
-                var chain = new List<CommonLineSpan>();
-                var points = new List<Vector> { EndOf(spans[span], entry) };
-                while (true)
-                {
-                    used[span] = true;
-                    chain.Add(spans[span]);
-                    var exit = 1 - entry;
-                    if (links[span, exit] is not { } next || used[next.Span])
-                    {
-                        points.Add(EndOf(spans[span], exit));
-                        break;
-                    }
-                    points.Add(next.Corner);
-                    (span, entry) = (next.Span, next.End);
-                }
-                paths.Add(new CommonLinePath(spans[i].First, spans[i].Second, chain, points));
-            }
-            return paths;
-        }
-
-        // Where span a's end ea meets span b's end eb at a corner, or null.
-        private static Vector? Corner(CommonLineSpan a, int ea, CommonLineSpan b, int eb, double kerf)
-        {
-            var aEnd = EndOf(a, ea);
-            var aOther = EndOf(a, 1 - ea);
-            var bEnd = EndOf(b, eb);
-            var bOther = EndOf(b, 1 - eb);
-            var aLength = aEnd.DistanceTo(aOther);
-            var bLength = bEnd.DistanceTo(bOther);
-            if (aLength <= Math.Tolerance.Epsilon || bLength <= Math.Tolerance.Epsilon)
-                return null;
-            // Travel along a into its end, then out along b from its end.
-            var din = new Vector((aEnd.X - aOther.X) / aLength, (aEnd.Y - aOther.Y) / aLength);
-            var dout = new Vector((bOther.X - bEnd.X) / bLength, (bOther.Y - bEnd.Y) / bLength);
-            var cross = Cross(din, dout);
-            var turn = PortableMath.Atan2(System.Math.Abs(cross), Dot(din, dout));
-            if (turn < MinCornerTurn || turn > MaxCornerTurn)
-                return null;
-            // aEnd + din·s = bEnd − dout·t: the corner lies s past a's end and t before b's end.
-            var gap = bEnd - aEnd;
-            var s = Cross(gap, dout) / cross;
-            var t = Cross(din, gap) / cross;
-            var reach = kerf / 2 * PortableMath.Tan(turn / 2) + 2 * GapTolerance;
-            if (s < -GapTolerance || t < -GapTolerance || s > reach || t > reach)
-                return null;
-            return new Vector(aEnd.X + din.X * s, aEnd.Y + din.Y * s);
-        }
-
-        private static Vector EndOf(CommonLineSpan span, int end) => end == 0 ? span.Start : span.End;
-
-        private static bool SamePair(CommonLineSpan a, CommonLineSpan b) =>
-            (ReferenceEquals(a.First, b.First) && ReferenceEquals(a.Second, b.Second))
-            || (ReferenceEquals(a.First, b.Second) && ReferenceEquals(a.Second, b.First));
-
-        private static IReadOnlyList<CommonLineSpan> Spans(Part first, IReadOnlyList<Edge> a, Part second,
-            IReadOnlyList<Edge> b, double kerf)
-        {
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                throw new ArgumentOutOfRangeException(nameof(kerf));
-            var spans = new List<CommonLineSpan>();
-            foreach (var facing in FacingEdges(a, b, kerf - GapTolerance, kerf + GapTolerance))
-            {
-                var edge = facing.First;
-                var half = facing.Gap / 2;
-                Vector At(double t) => new(edge.Start.X + edge.Direction.X * t + edge.Outward.X * half,
-                    edge.Start.Y + edge.Direction.Y * t + edge.Outward.Y * half);
-                spans.Add(new CommonLineSpan(first, second, At(facing.From), At(facing.To)));
-            }
-            return spans;
-        }
-
-        internal static IEnumerable<Facing> FacingEdges(IReadOnlyList<Edge> a, IReadOnlyList<Edge> b,
-            double minGap, double maxGap)
-        {
-            foreach (var first in a)
-                foreach (var second in b)
-                {
-                    // Antiparallel edges with opposed outward normals face each other.
-                    if (System.Math.Abs(Cross(first.Direction, second.Direction)) > ParallelTolerance
-                        || Dot(first.Outward, second.Outward) > -1 + ParallelTolerance)
-                        continue;
-                    var gap = Dot(second.Start - first.Start, first.Outward);
-                    if (gap < minGap || gap > maxGap)
-                        continue;
-                    var t0 = Dot(second.Start - first.Start, first.Direction);
-                    var t1 = Dot(second.End - first.Start, first.Direction);
-                    var from = System.Math.Max(0, System.Math.Min(t0, t1));
-                    var to = System.Math.Min(first.Length, System.Math.Max(t0, t1));
-                    if (to - from >= MinSharedLength)
-                        yield return new Facing(first, second, gap, from, to);
-                }
-        }
-
-        /// <summary>The straight edges of a part's placed clean perimeter, with outward normals.</summary>
-        internal static IReadOnlyList<Edge> Edges(Part part, ProfileCache cache)
-        {
-            var profile = PartSpacingReview.Profile(part, cache.Profiles)
-                ?? throw new ArgumentException("Part has no material.");
-            var location = part.Location;
-            var ring = profile.Perimeter.ToPolygon();
-            var edges = new List<Edge>();
-            foreach (var line in profile.Perimeter.Entities.OfType<Line>())
-            {
-                var start = line.StartPoint + location;
-                var end = line.EndPoint + location;
-                var length = start.DistanceTo(end);
-                if (length < MinSharedLength)
-                    continue;
-                var direction = new Vector((end.X - start.X) / length, (end.Y - start.Y) / length);
-                var outward = new Vector(direction.Y, -direction.X);
-                // The probe is in part-local coordinates: the ring is not moved to the location.
-                var mid = new Vector((line.StartPoint.X + line.EndPoint.X) / 2, (line.StartPoint.Y + line.EndPoint.Y) / 2);
-                var step = System.Math.Min(0.001, length / 100);
-                if (Inside(ring.Vertices, new Vector(mid.X + outward.X * step, mid.Y + outward.Y * step)))
-                    outward = new Vector(-outward.X, -outward.Y);
-                edges.Add(new Edge(start, end, direction, outward, length));
-            }
-            return edges;
-        }
-
-        internal sealed class ProfileCache
-        {
-            public readonly Dictionary<(Program, long), ShapeProfile> Profiles = new();
-        }
-
-        private static bool Connected(IReadOnlyList<List<int>> links)
-        {
-            var seen = new bool[links.Count];
-            var stack = new Stack<int>();
-            stack.Push(0);
-            seen[0] = true;
-            while (stack.Count > 0)
-                foreach (var next in links[stack.Pop()])
-                    if (!seen[next])
-                    {
-                        seen[next] = true;
-                        stack.Push(next);
-                    }
-            return seen.All(s => s);
-        }
-
-        private static bool Inside(IReadOnlyList<Vector> ring, Vector point)
-        {
-            var inside = false;
-            for (int i = 0, j = ring.Count - 1; i < ring.Count; j = i++)
-            {
-                var a = ring[i];
-                var b = ring[j];
-                if ((a.Y > point.Y) != (b.Y > point.Y)
-                    && point.X < (b.X - a.X) * (point.Y - a.Y) / (b.Y - a.Y) + a.X)
-                    inside = !inside;
-            }
-            return inside;
-        }
-
-        private static double Dot(Vector a, Vector b) => a.X * b.X + a.Y * b.Y;
-
-        private static double Cross(Vector a, Vector b) => a.X * b.Y - a.Y * b.X;
-
-        private static bool IsInvalid(Exception exception) => exception is
-            ArgumentException or InvalidOperationException or NotSupportedException or ArithmeticException;
-    }
-}

OpenNest.Core/CommonLines/CommonLineGroup.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace OpenNest.CommonLines
-{
-    /// <summary>
-    /// Parts placed exactly one kerf apart along collinear straight edges, so one centerline cut
-    /// makes both edges (see docs/common-line-cutting.md). Membership is by reference; the shared
-    /// spans are derived from the parts' placed geometry (<see cref="CommonLineGeometry"/>), never
-    /// stored, so a moved member breaks the group rather than leaving a stale span behind.
-    /// </summary>
-    public sealed class CommonLineGroup
-    {
-        private readonly List<Part> members;
-
-        /// <exception cref="ArgumentOutOfRangeException">The kerf is not finite and positive.</exception>
-        /// <exception cref="ArgumentException">Fewer than two distinct parts, a null part or a cut-off.</exception>
-        public CommonLineGroup(IEnumerable<Part> members, double kerf)
-        {
-            ArgumentNullException.ThrowIfNull(members);
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                throw new ArgumentOutOfRangeException(nameof(kerf), kerf, "A common line needs a finite, positive kerf.");
-            var distinct = new List<Part>();
-            foreach (var part in members)
-            {
-                if (part == null)
-                    throw new ArgumentException("A common-line group cannot hold a null part.", nameof(members));
-                if (part.BaseDrawing?.IsCutOff == true)
-                    throw new ArgumentException("A cut-off cannot share a common line.", nameof(members));
-                if (!distinct.Any(existing => ReferenceEquals(existing, part)))
-                    distinct.Add(part);
-            }
-            if (distinct.Count < 2)
-                throw new ArgumentException("A common-line group needs at least two parts.", nameof(members));
-            this.members = distinct;
-            Kerf = kerf;
-        }
-
-        /// <summary>The parts in the group, in the order they were joined.</summary>
-        public IReadOnlyList<Part> Members => members;
-
-        /// <summary>The gap the members were placed at: the kerf width when the group was made.</summary>
-        public double Kerf { get; }
-
-        public bool Contains(Part part) => members.Any(member => ReferenceEquals(member, part));
-
-        /// <summary>Drops a member (a part removed from the plate); true when it was one.</summary>
-        internal bool Remove(Part part) => members.RemoveAll(member => ReferenceEquals(member, part)) > 0;
-    }
-}

OpenNest.Core/CommonLines/CommonLineJoiner.cs

@@ -1,88 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Geometry;
-
-namespace OpenNest.CommonLines
-{
-    /// <summary>The outcome of <see cref="CommonLineJoiner.Join"/>: the group made, or why not.</summary>
-    public sealed record CommonLineJoinResult(CommonLineGroup Group, string Failure)
-    {
-        public bool Succeeded => Group != null;
-    }
-
-    /// <summary>
-    /// Slides parts together one kerf apart along their best facing straight edges and groups them
-    /// for common-line cutting. Parts already in a group move with their whole group, which joins
-    /// the new one. Nothing moves unless every part finds a partner and the result is an intact group.
-    /// </summary>
-    public static class CommonLineJoiner
-    {
-        /// <param name="maxGap">How far apart facing edges may start (or overlap) and still be joined.</param>
-        public static CommonLineJoinResult Join(Plate plate, IReadOnlyList<Part> parts, double kerf, double maxGap)
-        {
-            ArgumentNullException.ThrowIfNull(plate);
-            ArgumentNullException.ThrowIfNull(parts);
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                return new(null, "The plate has no kerf for its material and thickness, so parts cannot share a common line.");
-            if (!double.IsFinite(maxGap) || maxGap < kerf)
-                maxGap = kerf;
-            var selected = parts.Where(part => part != null && !part.BaseDrawing.IsCutOff).Distinct().ToList();
-            if (selected.Any(part => !plate.Parts.Contains(part)))
-                return new(null, "Every part in a common line must be on the plate.");
-
-            // A part already in a group brings its whole group, which moves as one unit.
-            var units = new List<List<Part>>();
-            foreach (var part in selected)
-            {
-                if (units.Any(unit => unit.Contains(part)))
-                    continue;
-                units.Add(plate.CommonLineGroupOf(part) is { } group ? group.Members.ToList() : new List<Part> { part });
-            }
-            if (units.Sum(unit => unit.Count) < 2)
-                return new(null, "Select at least two parts to share a common line.");
-
-            var start = units.SelectMany(unit => unit).ToDictionary(part => part, part => part.Location);
-            // Anchor the unit nearest the plate origin; join the rest to whatever is placed.
-            var placed = units.OrderBy(unit => unit.Min(part => part.BoundingBox.Left + part.BoundingBox.Bottom)).First();
-            var anchored = new List<Part>(placed);
-            var remaining = units.Where(unit => unit != placed).ToList();
-            while (remaining.Count > 0)
-            {
-                var best = remaining
-                    .SelectMany(unit => unit.SelectMany(candidate => anchored.Select(anchor =>
-                        (Unit: unit, Offset: CommonLineGeometry.JoinOffset(anchor, candidate, kerf, maxGap)))))
-                    .Where(choice => choice.Offset != null)
-                    .OrderBy(choice => choice.Offset!.Value.DistanceTo(Vector.Zero))
-                    .FirstOrDefault();
-                if (best.Unit == null)
-                {
-                    Restore(start);
-                    var names = string.Join(", ", remaining.SelectMany(unit => unit).Select(part => part.BaseDrawing.Name).Distinct());
-                    return new(null, $"No straight edge of {names} faces another selected part within {maxGap:0.###}. "
-                        + "Place the parts edge to edge first.");
-                }
-                foreach (var part in best.Unit)
-                    part.Offset(best.Offset!.Value);
-                anchored.AddRange(best.Unit);
-                remaining.Remove(best.Unit);
-            }
-
-            var trial = new CommonLineGroup(anchored, kerf);
-            var check = CommonLineGeometry.Check(trial);
-            if (!check.IsIntact)
-            {
-                Restore(start);
-                return new(null, $"'{check.Problems[0].Part.BaseDrawing.Name}' {check.Problems[0].Message}");
-            }
-            return new(plate.JoinCommonLine(anchored, kerf), null);
-        }
-
-        private static void Restore(Dictionary<Part, Vector> start)
-        {
-            foreach (var (part, location) in start)
-                if (part.Location != location)
-                    part.Offset(location - part.Location);
-        }
-    }
-}

OpenNest.Core/CommonLines/CommonLineUsage.cs

@@ -1,47 +0,0 @@
-namespace OpenNest.CommonLines
-{
-    /// <summary>
-    /// When automatic nesting and fills may place parts one kerf apart on a common line (see
-    /// docs/common-line-cutting.md). Only drawings with <see cref="Drawing.AllowCommonLine"/> take part.
-    /// </summary>
-    public enum CommonLineUsage
-    {
-        /// <summary>Never: engines and fills behave exactly as without common lines.</summary>
-        Off,
-
-        /// <summary>
-        /// Only when it places more parts (or, in a whole job, uses fewer sheets) than the best
-        /// layout without common lines; a tie keeps the layout without them.
-        /// </summary>
-        WhenItAddsParts,
-
-        /// <summary>
-        /// Whenever it shortens the cut or uses less material, never at the cost of a part:
-        /// part count still ranks first.
-        /// </summary>
-        Whenever,
-    }
-}
-
-namespace OpenNest.CommonLines
-{
-    /// <summary>The names <see cref="CommonLineUsage"/> is saved under (nest files and defaults.json).</summary>
-    public static class CommonLineUsageNames
-    {
-        /// <summary>The saved name, or null for <see cref="CommonLineUsage.Off"/> (omitted).</summary>
-        public static string Format(CommonLineUsage usage) => usage switch
-        {
-            CommonLineUsage.WhenItAddsParts => "whenItAddsParts",
-            CommonLineUsage.Whenever => "whenever",
-            _ => null,
-        };
-
-        /// <summary>Reads a saved name case-insensitively; anything else is off.</summary>
-        public static CommonLineUsage Parse(string name) =>
-            string.Equals(name, "whenItAddsParts", System.StringComparison.OrdinalIgnoreCase)
-                ? CommonLineUsage.WhenItAddsParts
-                : string.Equals(name, "whenever", System.StringComparison.OrdinalIgnoreCase)
-                    ? CommonLineUsage.Whenever
-                    : CommonLineUsage.Off;
-    }
-}

OpenNest.Core/Converters/ConvertGeometry.cs

@@ -186,9 +186,6 @@ namespace OpenNest.Converters
             if (string.Equals(name, SpecialLayers.DisplayPerimeter.Name, System.StringComparison.OrdinalIgnoreCase))
                 return LayerType.DisplayPerimeter;
 
-            if (string.Equals(name, SpecialLayers.CommonLine.Name, System.StringComparison.OrdinalIgnoreCase))
-                return LayerType.CommonLine;
-
             return LayerType.Cut;
         }
     }

OpenNest.Core/Converters/ConvertProgram.cs

@@ -216,9 +216,6 @@ namespace OpenNest.Converters
                 case LayerType.DisplayPerimeter:
                     return SpecialLayers.DisplayPerimeter;
 
-                case LayerType.CommonLine:
-                    return SpecialLayers.CommonLine;
-
                 default:
                     return new Layer(layer.ToString());
             }

OpenNest.Core/Converters/DrawingMarkRecovery.cs

@@ -57,7 +57,8 @@ public static class DrawingMarkRecovery
             return false;
 
         AppendMarks(drawing.Program, marks);
-        drawing.ProgramChanged();
+        drawing.UpdateArea();
+        drawing.RecomputeCanonicalAngle();
 
         foreach (var part in placedParts.Where(part => ReferenceEquals(part.BaseDrawing, drawing)
                      && !part.HasManualLeadIns))

OpenNest.Core/CutOff.cs

@@ -3,7 +3,7 @@ using System.Linq;
 using OpenNest.CNC;
 using OpenNest.Geometry;
 
-namespace OpenNest.CutOffs
+namespace OpenNest
 {
     public enum CutOffAxis
     {
@@ -11,13 +11,9 @@ namespace OpenNest.CutOffs
         Vertical,
     }
 
-    /// <summary>A stretch of a cut-off's line, along its axis, left uncut.</summary>
-    public readonly record struct CutOffGap(double Start, double End);
-
     public class CutOff
     {
         private const double OffsetTolerance = 0.001;
-        private IReadOnlyList<CutOffGap> gaps = System.Array.Empty<CutOffGap>();
 
         public Vector Position { get; set; }
         public CutOffAxis Axis { get; set; }
@@ -25,66 +21,6 @@ namespace OpenNest.CutOffs
         public double? EndLimit { get; set; }
         public Drawing Drawing { get; private set; }
 
-        /// <summary>
-        /// Stretches between the limits left uncut, so the line splits into pieces as it does
-        /// around a part; a trim of a middle piece makes one from crossing line to crossing line
-        /// (<see cref="CutOffTrim"/>). Kept sorted along the axis, with touching gaps merged and
-        /// empty or nonfinite ones dropped.
-        /// </summary>
-        public IReadOnlyList<CutOffGap> Gaps
-        {
-            get => gaps;
-            set => gaps = Normalize(value);
-        }
-
-        /// <summary>
-        /// The nominal line from <paramref name="start"/> to <paramref name="end"/> with its gaps
-        /// taken out, in ascending order: the pieces a consumer of the limits treats as cut.
-        /// </summary>
-        public IReadOnlyList<(double Start, double End)> Pieces(double start, double end) =>
-            Pieces(start, end, gaps);
-
-        internal static IReadOnlyList<(double Start, double End)> Pieces(double start, double end,
-            IReadOnlyList<CutOffGap> gaps)
-        {
-            var (low, high) = (System.Math.Min(start, end), System.Math.Max(start, end));
-            var pieces = new List<(double Start, double End)>();
-            if (gaps.Count == 0)
-            {
-                pieces.Add((low, high));
-                return pieces;
-            }
-            var current = low;
-            foreach (var gap in gaps)
-            {
-                if (gap.End <= current || gap.Start >= high)
-                    continue;
-                if (gap.Start > current)
-                    pieces.Add((current, gap.Start));
-                current = System.Math.Max(current, gap.End);
-            }
-            if (current < high)
-                pieces.Add((current, high));
-            return pieces;
-        }
-
-        private static IReadOnlyList<CutOffGap> Normalize(IEnumerable<CutOffGap> value)
-        {
-            var sorted = (value ?? Enumerable.Empty<CutOffGap>())
-                .Where(g => double.IsFinite(g.Start) && double.IsFinite(g.End) && g.End > g.Start)
-                .OrderBy(g => g.Start)
-                .ToList();
-            var merged = new List<CutOffGap>();
-            foreach (var gap in sorted)
-            {
-                if (merged.Count > 0 && gap.Start <= merged[^1].End + Math.Tolerance.Epsilon)
-                    merged[^1] = merged[^1] with { End = System.Math.Max(merged[^1].End, gap.End) };
-                else
-                    merged.Add(gap);
-            }
-            return merged.Count == 0 ? System.Array.Empty<CutOffGap>() : merged.AsReadOnly();
-        }
-
         /// <summary>
         /// How far past the nominal far sheet edge (the edge away from the plate's origin) the
         /// segment reaching that edge cuts with the head height locked; zero for none. Stock can
@@ -149,28 +85,6 @@ namespace OpenNest.CutOffs
             return result;
         }
 
-        /// <summary>
-        /// The cut strokes of a cut-off <paramref name="program"/>, offset by <paramref name="offset"/>:
-        /// one line per cutting move, from wherever the previous motion ended. Walks the motions rather
-        /// than pairing rapid and cut codes, because a head-locked far-edge segment carries lock
-        /// comments and a rapid return between its cuts.
-        /// </summary>
-        public static IEnumerable<Line> CutStrokes(Program program, Vector offset = default)
-        {
-            if (program == null)
-                yield break;
-            Vector? position = null;
-            foreach (var code in program.Codes)
-            {
-                if (code is not Motion motion)
-                    continue;
-                var end = motion.EndPoint + offset;
-                if (motion is LinearMove && position is { } start)
-                    yield return new Line(start, end);
-                position = end;
-            }
-        }
-
         /// <summary>
         /// Whether the far edge, along this axis on <paramref name="plate"/>, is the high
         /// coordinate: the sheet runs from the origin toward positive coordinates on that axis.
@@ -275,82 +189,21 @@ namespace OpenNest.CutOffs
         /// True when <paramref name="part"/>, the placed part of <paramref name="definition"/>, cuts
         /// one continuous straight line on the definition's axis across the whole sheet, so it
         /// splits the sheet in two. Anything else (gaps around parts, limits short of an edge, a
-        /// line on the sheet edge, a stale or unrecognized program) does not separate the sheet.
+        /// line on the sheet edge, a stale or unrecognised program) does not separate the sheet.
         /// </summary>
-        internal static bool SeparatesSheet(Part part, CutOff definition, Box sheet) =>
+        internal static bool SeparatesSheet(Part part, CutOff definition, Box sheet)
-            ContinuousCut(part, definition, sheet) is { } cut
-            && cut.Low <= (definition.Axis == CutOffAxis.Vertical ? sheet.Bottom : sheet.Left) + Math.Tolerance.Epsilon
-            && cut.High >= (definition.Axis == CutOffAxis.Vertical ? sheet.Top : sheet.Right) - Math.Tolerance.Epsilon;
-
-        /// <summary>
-        /// The cut-off parts among <paramref name="parts"/> that split off a piece of the sheet,
-        /// each with the round it was found in. Round 0 holds the lines that
-        /// <see cref="SeparatesSheet"/> across the whole sheet; a line of a later round is one
-        /// continuous cut from a sheet edge or an earlier round's line to another, such as the
-        /// last strip line stopping at a remnant's horizontal separator. It frees a piece together
-        /// with the lines it stops on, so it is cut after every other part and before those lines
-        /// (higher rounds first), keeping the remnant's mass on the sheet until the end.
-        /// </summary>
-        public static IReadOnlyDictionary<Part, int> Separators(IEnumerable<Part> parts, IEnumerable<CutOff> definitions, Box sheet)
-        {
-            var rounds = new Dictionary<Part, int>(ReferenceEqualityComparer.Instance);
-            if (parts == null || definitions == null || sheet == null)
-                return rounds;
-            var byDrawing = new Dictionary<Drawing, CutOff>(ReferenceEqualityComparer.Instance);
-            foreach (var definition in definitions)
-                if (definition?.Drawing != null)
-                    byDrawing[definition.Drawing] = definition;
-            var cuts = new List<(Part Part, bool Vertical, double Line, double Low, double High)>();
-            foreach (var part in parts)
-                if (part?.BaseDrawing is { IsCutOff: true } drawing && byDrawing.TryGetValue(drawing, out var definition)
-                    && ContinuousCut(part, definition, sheet) is { } cut)
-                {
-                    var vertical = definition.Axis == CutOffAxis.Vertical;
-                    cuts.Add((part, vertical, vertical ? definition.Position.X : definition.Position.Y, cut.Low, cut.High));
-                }
-
-            for (var round = 0; ; round++)
-            {
-                var found = cuts.Where(cut => !rounds.ContainsKey(cut.Part) && Bounded(cut)).ToList();
-                if (found.Count == 0)
-                    return rounds;
-                foreach (var cut in found)
-                    rounds[cut.Part] = round;
-            }
-
-            // The cut runs between two boundaries: sheet edges, or lines found in an earlier round
-            // that cross this one where they are cut. The stretch between them is cut, as the cut
-            // is continuous.
-            bool Bounded((Part Part, bool Vertical, double Line, double Low, double High) cut)
-            {
-                var reached = cuts.Where(other => other.Vertical != cut.Vertical && rounds.ContainsKey(other.Part)
-                        && other.Low <= cut.Line + Math.Tolerance.Epsilon && other.High >= cut.Line - Math.Tolerance.Epsilon)
-                    .Select(other => other.Line)
-                    .Append(cut.Vertical ? sheet.Bottom : sheet.Left)
-                    .Append(cut.Vertical ? sheet.Top : sheet.Right)
-                    .Where(b => b >= cut.Low - Math.Tolerance.Epsilon && b <= cut.High + Math.Tolerance.Epsilon)
-                    .ToList();
-                return reached.Count > 1 && reached.Max() - reached.Min() > Math.Tolerance.Epsilon;
-            }
-        }
-
-        /// <summary>The cut-off parts on <paramref name="plate"/> that split off a piece of it, by round.</summary>
-        public static IReadOnlyDictionary<Part, int> Separators(Plate plate) =>
-            Separators(plate.Parts, plate.CutOffs, plate.BoundingBox(includeParts: false));
-
-        // The extent along the line of a part that cuts one continuous straight line on its
-        // definition's line strictly inside the sheet, or null for anything else.
-        private static (double Low, double High)? ContinuousCut(Part part, CutOff definition, Box sheet)
         {
             if (part?.Program == null || definition == null || sheet == null
                 || part.Program.Mode != Mode.Absolute)
-                return null;
+                return false;
             var vertical = definition.Axis == CutOffAxis.Vertical;
             var line = vertical ? definition.Position.X : definition.Position.Y;
             var acrossMin = vertical ? sheet.Left : sheet.Bottom;
             var acrossMax = vertical ? sheet.Right : sheet.Top;
+            var alongMin = vertical ? sheet.Bottom : sheet.Left;
+            var alongMax = vertical ? sheet.Top : sheet.Right;
             if (!(line > acrossMin + Math.Tolerance.Epsilon && line < acrossMax - Math.Tolerance.Epsilon))
-                return null;
+                return false;
 
             Vector? position = null;
             double? low = null, high = null;
@@ -368,13 +221,13 @@ namespace OpenNest.CutOffs
                         // A second pierce leaves an uncut gap; a head-locked rapid returns along
                         // the overcut to where the cut toward the origin begins.
                         if (cutting && !locked)
-                            return null;
+                            return false;
                         position = rapid.EndPoint + part.Location;
                         break;
                     case LinearMove move when position != null:
                         var end = move.EndPoint + part.Location;
                         if (!OnLine(position.Value) || !OnLine(end))
-                            return null;
+                            return false;
                         foreach (var value in new[] { Along(position.Value), Along(end) })
                         {
                             low = low == null ? value : System.Math.Min(low.Value, value);
@@ -384,10 +237,10 @@ namespace OpenNest.CutOffs
                         cutting = true;
                         break;
                     case Motion:
-                        return null;
+                        return false;
                 }
             }
-            return cutting ? (low.Value, high.Value) : null;
+            return cutting && low <= alongMin + Math.Tolerance.Epsilon && high >= alongMax - Math.Tolerance.Epsilon;
 
             bool OnLine(Vector point) =>
                 System.Math.Abs((vertical ? point.X : point.Y) - line) <= Math.Tolerance.Epsilon;
@@ -409,8 +262,7 @@ namespace OpenNest.CutOffs
         {
             var bounds = plate.BoundingBox(includeParts: false);
             // A head-locked overcut replaces the overtravel at the high edge when that is the far edge.
-            var lockedFarEdge = LockedFarEdge(plate);
+            var overtravel = LockedFarEdge(plate) is { High: true } ? 0 : settings.Overtravel;
-            var overtravel = lockedFarEdge is { High: true } ? 0 : settings.Overtravel;
 
             double lineStart,
                 lineEnd,
@@ -429,13 +281,6 @@ namespace OpenNest.CutOffs
                 lineEnd = EndLimit ?? (bounds.X + bounds.Length + overtravel);
             }
 
-            // An outlined sheet is cut only where the line crosses material: each crossing is a
-            // span of its own, started at the material's edge and overtraveled past the far
-            // one, within the user's limits.
-            var spans = plate.Outline == null
-                ? new List<(double Start, double End)> { (lineStart, lineEnd) }
-                : MaterialSpans(plate, cutPosition, lineStart, lineEnd, settings.Overtravel, lockedFarEdge);
-
             var exclusions = new List<(double Start, double End)>();
 
             foreach (var part in plate.Parts)
@@ -468,8 +313,6 @@ namespace OpenNest.CutOffs
                 );
                 exclusions.AddRange(partExclusions);
             }
-            foreach (var gap in gaps)
-                exclusions.Add((gap.Start, gap.End));
 
             exclusions.Sort((a, b) => a.Start.CompareTo(b.Start));
             var merged = new List<(double Start, double End)>();
@@ -482,71 +325,27 @@ namespace OpenNest.CutOffs
             }
 
             var segments = new List<(double Start, double End)>();
-            foreach (var (spanStart, spanEnd) in spans)
+            var current = lineStart;
+
+            foreach (var ex in merged)
             {
-                var current = spanStart;
+                var clampedStart = System.Math.Max(ex.Start, lineStart);
+                var clampedEnd = System.Math.Min(ex.End, lineEnd);
 
-                foreach (var ex in merged)
+                if (clampedStart > current)
-                {
+                    segments.Add((current, clampedStart));
-                    var clampedStart = System.Math.Max(ex.Start, spanStart);
-                    var clampedEnd = System.Math.Min(ex.End, spanEnd);
 
-                    if (clampedStart > current)
+                current = System.Math.Max(current, clampedEnd);
-                        segments.Add((current, clampedStart));
-
-                    current = System.Math.Max(current, clampedEnd);
-                }
-
-                if (current < spanEnd)
-                    segments.Add((current, spanEnd));
             }
 
+            if (current < lineEnd)
+                segments.Add((current, lineEnd));
+
             segments = segments.Where(s => (s.End - s.Start) >= settings.MinSegmentLength).ToList();
 
             return segments;
         }
 
-        /// <summary>
-        /// Where the line at <paramref name="cutPosition"/> crosses the sheet's outlined material,
-        /// in ascending order along the axis and clipped to the line's limits. Each span starts at
-        /// the material edge and runs <paramref name="overtravel"/> past the far one unless a limit
-        /// or a head-locked far edge ends it there.
-        /// </summary>
-        private List<(double Start, double End)> MaterialSpans(Plate plate, double cutPosition,
-            double lineStart, double lineEnd, double overtravel, (double Edge, bool High)? lockedFarEdge)
-        {
-            var vertical = Axis == CutOffAxis.Vertical;
-            var crossings = new List<double>();
-            foreach (var path in plate.Outline.Material(plate.Outline.PlacementOrigin(plate.Quadrant)))
-            {
-                for (var i = 0; i < path.Count; i++)
-                {
-                    var a = path[i];
-                    var b = path[(i + 1) % path.Count];
-                    var (aAcross, aAlong) = vertical ? (a.x, a.y) : (a.y, a.x);
-                    var (bAcross, bAlong) = vertical ? (b.x, b.y) : (b.y, b.x);
-                    // Half-open on the across axis, so a line through a vertex counts one edge.
-                    if (aAcross <= cutPosition == bAcross <= cutPosition)
-                        continue;
-                    crossings.Add(aAlong + (bAlong - aAlong) * (cutPosition - aAcross) / (bAcross - aAcross));
-                }
-            }
-            crossings.Sort();
-
-            var spans = new List<(double Start, double End)>();
-            for (var i = 0; i + 1 < crossings.Count; i += 2)
-            {
-                var start = System.Math.Max(crossings[i], lineStart);
-                var end = crossings[i + 1];
-                var limited = EndLimit != null && end >= EndLimit.Value
-                    || lockedFarEdge is var (edge, high) && high && end == edge;
-                end = System.Math.Min(limited ? end : end + overtravel, lineEnd);
-                if (end > start)
-                    spans.Add((start, end));
-            }
-            return spans;
-        }
-
         private static readonly List<(double Start, double End)> EmptyExclusions = new();
 
         private List<(double Start, double End)> GetPartExclusions(

OpenNest.Core/CutOffSegments.cs

@@ -2,15 +2,15 @@ using System.Collections.Generic;
 using OpenNest.CNC;
 using OpenNest.Geometry;
 
-namespace OpenNest.CutOffs
+namespace OpenNest
 {
     /// <summary>
     /// One placed cutting segment of a cut-off: the part that cuts it, where its cut runs along
     /// the cut-off's axis, and the span of the nominal line it stands for, from the end of the
     /// segment before it (or the line's start) to the start of the one after it (or the line's
-    /// end), stopping short of a <see cref="CutOff.Gaps">gap</see> between them. The parts the
+    /// end). The parts the nominal line passes through lie in the gaps between segments, so each
-    /// nominal line passes through lie in the gaps between segments, so each is inside the span
+    /// is inside the span of the segment on either side of it; a segment is cut before exactly
-    /// of the segment on either side of it; a segment is cut before exactly those parts.
+    /// those parts.
     /// </summary>
     public sealed record CutOffSegment(Part Part, double Start, double End, double SpanStart, double SpanEnd);
 
@@ -55,14 +55,6 @@ namespace OpenNest.CutOffs
                 var (part, start, end) = measured[i];
                 var spanStart = i == 0 ? System.Math.Min(low, start) : measured[i - 1].End;
                 var spanEnd = i == measured.Count - 1 ? System.Math.Max(high, end) : measured[i + 1].Start;
-                // A gap between two segments belongs to neither: each span stops at its edge.
-                foreach (var gap in definition.Gaps)
-                {
-                    if (i > 0 && gap.End <= start + Math.Tolerance.Epsilon && gap.End > spanStart)
-                        spanStart = gap.End;
-                    if (i < measured.Count - 1 && gap.Start >= end - Math.Tolerance.Epsilon && gap.Start < spanEnd)
-                        spanEnd = gap.Start;
-                }
                 result.Add(new CutOffSegment(part, start, end, spanStart, spanEnd));
             }
             result.AddRange(whole);

OpenNest.Core/CutOffSettings.cs

@@ -1,4 +1,4 @@
-namespace OpenNest.CutOffs
+namespace OpenNest
 {
     public enum CutDirection
     {
@@ -25,7 +25,5 @@ namespace OpenNest.CutOffs
 
         /// <summary>The head-locked overcut a new cut-off gets from these settings; zero when off.</summary>
         public double NewCutOffHeadLockOvercut => LockHeadHeight ? HeadLockOvercut : 0;
-
-        public CutOffSettings Copy() => (CutOffSettings)MemberwiseClone();
     }
 }

OpenNest.Core/CutOffs/CutOffTrim.cs

@@ -1,500 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.CutOffs
-{
-    /// <summary>
-    /// The limits and gaps one cut-off takes when a <see cref="CutOffEdit"/> is applied; null
-    /// <paramref name="Gaps"/> keeps the cut-off's gaps.
-    /// </summary>
-    public sealed record CutOffLimitChange(CutOff CutOff, double? StartLimit, double? EndLimit,
-        IReadOnlyList<CutOffGap> Gaps = null)
-    {
-        /// <summary>The gaps the cut-off has once the change is applied.</summary>
-        public IReadOnlyList<CutOffGap> NewGaps => Gaps ?? CutOff.Gaps;
-    }
-
-    /// <summary>
-    /// A worked-out trim, extend or swap: the new limits and gaps of each cut-off it changes, or
-    /// why it was refused. Nothing changes until <see cref="Apply"/>; the caller then regenerates
-    /// the plate's cut-offs and places their segments in the cutting order.
-    /// </summary>
-    public sealed class CutOffEdit
-    {
-        private CutOffEdit(IReadOnlyList<CutOffLimitChange> changes, string refusal, string notice)
-        {
-            Changes = changes;
-            Refusal = refusal;
-            Notice = notice;
-        }
-
-        public IReadOnlyList<CutOffLimitChange> Changes { get; }
-
-        /// <summary>Why the edit cannot be made; null when it can.</summary>
-        public string Refusal { get; }
-
-        /// <summary>Something the operator should know once it is made, such as a head-locked overcut turning off.</summary>
-        public string Notice { get; }
-
-        public bool Succeeded => Refusal == null;
-
-        internal static CutOffEdit Refused(string reason) => new(System.Array.Empty<CutOffLimitChange>(), reason, null);
-
-        internal static CutOffEdit Of(IReadOnlyList<CutOffLimitChange> changes, string notice) => new(changes, null, notice);
-
-        public void Apply()
-        {
-            if (!Succeeded)
-                throw new System.InvalidOperationException(Refusal);
-            foreach (var change in Changes)
-            {
-                change.CutOff.StartLimit = change.StartLimit;
-                change.CutOff.EndLimit = change.EndLimit;
-                if (change.Gaps != null)
-                    change.CutOff.Gaps = change.Gaps;
-            }
-        }
-    }
-
-    /// <summary>
-    /// The perpendicular lines that meet a cut-off as a drag of it starts: their limits or gap
-    /// edges sit on its center, where a trim or extend left them. <see cref="MoveTo"/> takes those
-    /// stops along, so each line is extended or trimmed to keep meeting it. Every move works from
-    /// the lines as they were at the start, so a stop held back partway is restored on the way
-    /// back. A stop never passes the next one on its line: it stays a minimum segment short of it,
-    /// or of the sheet edge.
-    /// </summary>
-    public sealed class CutOffJoints
-    {
-        private readonly List<(CutOff CutOff, double? StartLimit, double? EndLimit, IReadOnlyList<CutOffGap> Gaps)> joined;
-        private readonly double from;
-        private readonly double sheetLow;
-        private readonly double sheetHigh;
-        private readonly double minimum;
-
-        internal CutOffJoints(IEnumerable<CutOff> lines, double from, double sheetLow, double sheetHigh, double minimum)
-        {
-            joined = lines.Select(c => (c, c.StartLimit, c.EndLimit, c.Gaps)).ToList();
-            this.from = from;
-            this.sheetLow = sheetLow;
-            this.sheetHigh = sheetHigh;
-            this.minimum = minimum;
-        }
-
-        /// <summary>The lines that follow the cut-off.</summary>
-        public IReadOnlyList<CutOff> Lines => joined.Select(j => j.CutOff).ToList();
-
-        /// <summary>Moves the joined stops to <paramref name="line"/>, the cut-off's new center.</summary>
-        public void MoveTo(double line)
-        {
-            foreach (var (cutOff, startLimit, endLimit, gaps) in joined)
-            {
-                var stops = gaps.SelectMany(g => new[] { g.Start, g.End })
-                    .Append(startLimit ?? sheetLow)
-                    .Append(endLimit ?? sheetHigh)
-                    .ToList();
-                var below = stops.Where(s => s < from - Tolerance.Epsilon).DefaultIfEmpty(sheetLow).Max();
-                var above = stops.Where(s => s > from + Tolerance.Epsilon).DefaultIfEmpty(sheetHigh).Min();
-                var at = System.Math.Clamp(line,
-                    System.Math.Min(below + minimum, from), System.Math.Max(above - minimum, from));
-
-                cutOff.StartLimit = startLimit is double start ? Follow(start, at) : null;
-                cutOff.EndLimit = endLimit is double end ? Follow(end, at) : null;
-                cutOff.Gaps = gaps.Select(g => new CutOffGap(Follow(g.Start, at), Follow(g.End, at))).ToList();
-            }
-        }
-
-        private double Follow(double stop, double at) =>
-            System.Math.Abs(stop - from) <= Tolerance.Epsilon ? at : stop;
-    }
-
-    /// <summary>
-    /// Trims and extends cut-offs against the cut-offs that cross them, by changing only their
-    /// start and end limits and their gaps (see docs/automatic-scrap-cutoffs.md, "Trim and
-    /// extend"). A trim stops on the crossing line's center, inside its kerf; trimming a piece
-    /// between two crossing lines leaves a gap from one center to the other. An extend closes the
-    /// gap at the picked end, or runs the line's end to the next crossing line beyond it, or to
-    /// the sheet edge, which clears the limit.
-    /// </summary>
-    public static class CutOffTrim
-    {
-        public const string NotOnPlate = "That cut-off is not on this plate.";
-        public const string NothingToTrimTo = "No cut-off crosses this line to trim it to; delete it instead.";
-        public const string InGap = "That stretch of the line is already uncut.";
-        public const string TooShort = "Trimming here would leave a line shorter than the minimum segment length.";
-        public const string AtSheetEdge = "This end already runs to the sheet edge.";
-        public const string NotAJunction = "These cut-offs do not meet with one running through and the other stopping at it.";
-        public const string GapAtJunction = "A gap in one of these lines meets the junction; extend to close it before swapping.";
-        public const string OvercutOff = "The head-locked overcut is off while this line stops short of the far edge.";
-        public const string OvercutOn = "The head-locked overcut is back on at the far edge.";
-
-        /// <summary>
-        /// Removes the piece of <paramref name="target"/> picked at <paramref name="pick"/>, between
-        /// the crossing cut-offs on either side of it, or a gap or the line's end where there is no
-        /// crossing on that side. An end piece moves that end's limit; a piece between two crossing
-        /// lines becomes a gap, merged with any gap it touches.
-        /// </summary>
-        public static CutOffEdit Trim(Plate plate, CutOff target, Vector pick, CutOffSettings settings)
-        {
-            if (!plate.CutOffs.Contains(target))
-                return CutOffEdit.Refused(NotOnPlate);
-            var (start, end) = NominalSpan(plate, target);
-            var at = System.Math.Clamp(Along(target, pick), start, end);
-            var pieces = target.Pieces(start, end);
-            var piece = pieces.Where(p => at >= p.Start - Tolerance.Epsilon && at <= p.End + Tolerance.Epsilon)
-                .Cast<(double Start, double End)?>().FirstOrDefault();
-            if (piece is not var (pieceStart, pieceEnd))
-                return CutOffEdit.Refused(InGap);
-
-            var crossings = Crossings(plate, target)
-                .Where(c => c > pieceStart + Tolerance.Epsilon && c < pieceEnd - Tolerance.Epsilon)
-                .ToList();
-            var low = crossings.Where(c => c <= at).DefaultIfEmpty(pieceStart).Max();
-            var high = crossings.Where(c => c > at).DefaultIfEmpty(pieceEnd).Min();
-            if (pieces.Count == 1 && low == start && high == end)
-                return CutOffEdit.Refused(NothingToTrimTo);
-
-            var remaining = new List<(double Start, double End)>();
-            foreach (var (from, to) in pieces)
-            {
-                if (from < low)
-                    remaining.Add((from, System.Math.Min(to, low)));
-                if (to > high)
-                    remaining.Add((System.Math.Max(from, high), to));
-            }
-            var minimum = System.Math.Max(settings?.MinSegmentLength ?? 0, Tolerance.Epsilon);
-            if (remaining.Count == 0
-                || remaining.Any(p => (p.End == low || p.Start == high) && p.End - p.Start < minimum))
-                return CutOffEdit.Refused(TooShort);
-            return Single(plate, Change(target, start, end, remaining));
-        }
-
-        /// <summary>
-        /// Lengthens <paramref name="target"/> at the end of the piece nearer <paramref name="pick"/>:
-        /// a gap there closes; the line's own end runs to the next crossing cut-off beyond it, or to
-        /// the sheet edge when there is none. A cut-off sitting at the current end is skipped, so
-        /// picking again extends one more step. A pick inside a gap closes that gap.
-        /// </summary>
-        public static CutOffEdit Extend(Plate plate, CutOff target, Vector pick)
-        {
-            if (!plate.CutOffs.Contains(target))
-                return CutOffEdit.Refused(NotOnPlate);
-            var (start, end) = NominalSpan(plate, target);
-            var at = Along(target, pick);
-            var gaps = target.Gaps;
-            var inside = gaps.Where(g => at > g.Start && at < g.End).ToList();
-            if (inside.Count == 0)
-            {
-                var pieces = target.Pieces(start, end);
-                var piece = pieces.OrderBy(p => Distance(at, p)).First();
-                var high = System.Math.Abs(at - piece.End) <= System.Math.Abs(at - piece.Start);
-                var edge = high ? piece.End : piece.Start;
-                inside = gaps.Where(g => System.Math.Abs((high ? g.Start : g.End) - edge) <= Tolerance.Epsilon).ToList();
-                if (inside.Count == 0)
-                {
-                    return ExtendEnd(plate, target, high, out var limit)
-                        ? Single(plate, new CutOffLimitChange(target,
-                            high ? target.StartLimit : limit, high ? limit : target.EndLimit))
-                        : CutOffEdit.Refused(AtSheetEdge);
-                }
-            }
-            return Single(plate, new CutOffLimitChange(target, target.StartLimit, target.EndLimit,
-                gaps.Except(inside).ToList()));
-        }
-
-        /// <summary>
-        /// Stops a new <paramref name="target"/> at the first crossing cut-off from its start edge,
-        /// the origin side unless <paramref name="settings"/> cut toward the origin. It stays full
-        /// length, with no changes, when nothing crosses it or the line left would be shorter than
-        /// the minimum segment length. <paramref name="target"/> need not be on the plate yet.
-        /// </summary>
-        public static CutOffEdit StopAtFirstCrossing(Plate plate, CutOff target, CutOffSettings settings)
-        {
-            var (start, end) = NominalSpan(plate, target);
-            var crossings = Crossings(plate, target)
-                .Where(c => c > start + Tolerance.Epsilon && c < end - Tolerance.Epsilon)
-                .ToList();
-            if (crossings.Count == 0)
-                return CutOffEdit.Of(System.Array.Empty<CutOffLimitChange>(), null);
-
-            var towardOrigin = settings?.CutDirection == CutDirection.TowardOrigin;
-            var startsHigh = towardOrigin == CutOff.FarEdgeIsHigh(target.Axis, plate.Quadrant);
-            var stop = startsHigh ? crossings.Max() : crossings.Min();
-            var remaining = startsHigh ? end - stop : stop - start;
-            if (remaining < System.Math.Max(settings?.MinSegmentLength ?? 0, Tolerance.Epsilon))
-                return CutOffEdit.Of(System.Array.Empty<CutOffLimitChange>(), null);
-            return startsHigh
-                ? Single(plate, new CutOffLimitChange(target, stop, target.EndLimit))
-                : Single(plate, new CutOffLimitChange(target, target.StartLimit, stop));
-        }
-
-        /// <summary>
-        /// The lines that meet <paramref name="moved"/> and follow it when it moves: perpendicular
-        /// cut-offs with a limit or gap edge on its center, where its own cut pieces reach them. A
-        /// line that only ends level with it, past its end or in one of its gaps, stays put.
-        /// </summary>
-        public static CutOffJoints Joints(Plate plate, CutOff moved, CutOffSettings settings)
-        {
-            var at = Line(moved);
-            var (movedStart, movedEnd) = NominalSpan(plate, moved);
-            var pieces = moved.Pieces(movedStart, movedEnd);
-            var lines = plate.CutOffs
-                .Where(other => other != moved && other.Axis != moved.Axis)
-                .Where(other => pieces.Any(p => Within(Line(other), p.Start, p.End)))
-                .Where(other => Stops(other).Any(stop => System.Math.Abs(stop - at) <= Tolerance.Epsilon));
-
-            var sheet = plate.BoundingBox(includeParts: false);
-            var horizontal = moved.Axis == CutOffAxis.Vertical;
-            return new CutOffJoints(lines, at, horizontal ? sheet.Left : sheet.Bottom,
-                horizontal ? sheet.Right : sheet.Top,
-                System.Math.Max(settings?.MinSegmentLength ?? 0, Tolerance.Epsilon));
-        }
-
-        // Where the cut-off's own limits and gaps stop it, not counting the sheet edges.
-        private static IEnumerable<double> Stops(CutOff cutOff)
-        {
-            if (cutOff.StartLimit is double start)
-                yield return start;
-            if (cutOff.EndLimit is double end)
-                yield return end;
-            foreach (var gap in cutOff.Gaps)
-            {
-                yield return gap.Start;
-                yield return gap.End;
-            }
-        }
-
-        /// <summary>
-        /// Swaps which of two meeting cut-offs runs through: the one that stopped at the junction
-        /// extends past it (as <see cref="Extend"/> does), and the one that ran through is trimmed
-        /// there, losing the side away from the plate's origin and any gaps on it. Only the
-        /// origin-side sheet edge is certain, so the trimmed line keeps starting there. Refused when
-        /// a gap in either line meets the junction.
-        /// </summary>
-        public static CutOffEdit Swap(Plate plate, CutOff first, CutOff second, CutOffSettings settings)
-        {
-            if (!plate.CutOffs.Contains(first) || !plate.CutOffs.Contains(second))
-                return CutOffEdit.Refused(NotOnPlate);
-            if (first != second && first.Axis != second.Axis
-                && (TouchesGap(first, Line(second)) || TouchesGap(second, Line(first))))
-                return CutOffEdit.Refused(GapAtJunction);
-            if (Junction(plate, first, second) is not var (through, stopper, point))
-                return CutOffEdit.Refused(NotAJunction);
-
-            var (start, end) = NominalSpan(plate, through);
-            var farHigh = CutOff.FarEdgeIsHigh(through.Axis, plate.Quadrant);
-            var kept = through.Pieces(start, end)
-                .Select(p => farHigh ? (p.Start, System.Math.Min(p.End, point)) : (System.Math.Max(p.Start, point), p.End))
-                .Where(p => p.Item2 > p.Item1)
-                .ToList();
-            var adjacent = kept.FirstOrDefault(p => (farHigh ? p.Item2 : p.Item1) == point);
-            if (kept.Count == 0
-                || adjacent.Item2 - adjacent.Item1 < System.Math.Max(settings?.MinSegmentLength ?? 0, Tolerance.Epsilon))
-                return CutOffEdit.Refused(TooShort);
-            var throughChange = farHigh
-                ? new CutOffLimitChange(through, through.StartLimit, point, GapsBetween(kept))
-                : new CutOffLimitChange(through, point, through.EndLimit, GapsBetween(kept));
-
-            var (stopStart, stopEnd) = NominalSpan(plate, stopper);
-            var stopperPoint = Line(through);
-            var high = System.Math.Abs(stopperPoint - stopEnd) <= System.Math.Abs(stopperPoint - stopStart);
-            if (!ExtendEnd(plate, stopper, high, out var limit))
-                return CutOffEdit.Refused(NotAJunction);
-            var stopperChange = high
-                ? new CutOffLimitChange(stopper, stopper.StartLimit, limit)
-                : new CutOffLimitChange(stopper, limit, stopper.EndLimit);
-
-            var notices = new[] { Notice(plate, throughChange), Notice(plate, stopperChange) }
-                .Where(n => n != null).Distinct().ToList();
-            return CutOffEdit.Of(new[] { stopperChange, throughChange },
-                notices.Count == 0 ? null : string.Join(" ", notices));
-        }
-
-        /// <summary>
-        /// The two cut-offs meeting within <paramref name="tolerance"/> of <paramref name="point"/>,
-        /// one running through the junction and the other stopping at it; null when there is none.
-        /// </summary>
-        public static (CutOff Through, CutOff Stopper)? JunctionAt(Plate plate, Vector point, double tolerance)
-        {
-            if (plate?.CutOffs == null)
-                return null;
-            (CutOff, CutOff)? best = null;
-            var bestDistance = double.MaxValue;
-            foreach (var vertical in plate.CutOffs.Where(c => c.Axis == CutOffAxis.Vertical))
-                foreach (var horizontal in plate.CutOffs.Where(c => c.Axis == CutOffAxis.Horizontal))
-                {
-                    if (Junction(plate, vertical, horizontal) is not var (through, stopper, _))
-                        continue;
-                    var distance = new Vector(vertical.Position.X, horizontal.Position.Y).DistanceTo(point);
-                    if (distance <= tolerance && distance < bestDistance)
-                    {
-                        best = (through, stopper);
-                        bestDistance = distance;
-                    }
-                }
-            return best;
-        }
-
-        /// <summary>
-        /// Where <paramref name="cutOff"/>'s line runs along its axis: its limits, or the sheet
-        /// edges where it has none. Overtravel is not part of the nominal line, and neither does it
-        /// take out the gaps (see <see cref="CutOff.Pieces(double, double)"/>).
-        /// </summary>
-        public static (double Start, double End) NominalSpan(Plate plate, CutOff cutOff)
-        {
-            var sheet = plate.BoundingBox(includeParts: false);
-            var vertical = cutOff.Axis == CutOffAxis.Vertical;
-            return (cutOff.StartLimit ?? (vertical ? sheet.Bottom : sheet.Left),
-                cutOff.EndLimit ?? (vertical ? sheet.Top : sheet.Right));
-        }
-
-        /// <summary>
-        /// The stretches of the nominal line a change removes and adds, along the axis, in ascending
-        /// order: what a preview marks.
-        /// </summary>
-        public static (IReadOnlyList<(double Start, double End)> Removed, IReadOnlyList<(double Start, double End)> Added)
-            Difference(Plate plate, CutOffLimitChange change)
-        {
-            var cutOff = change.CutOff;
-            var sheet = plate.BoundingBox(includeParts: false);
-            var vertical = cutOff.Axis == CutOffAxis.Vertical;
-            var before = cutOff.Pieces(NominalSpan(plate, cutOff).Start, NominalSpan(plate, cutOff).End);
-            var after = CutOff.Pieces(change.StartLimit ?? (vertical ? sheet.Bottom : sheet.Left),
-                change.EndLimit ?? (vertical ? sheet.Top : sheet.Right), change.NewGaps);
-            return (Subtract(before, after), Subtract(after, before));
-        }
-
-        private static List<(double Start, double End)> Subtract(
-            IReadOnlyList<(double Start, double End)> from, IReadOnlyList<(double Start, double End)> remove)
-        {
-            var result = new List<(double Start, double End)>();
-            foreach (var piece in from)
-            {
-                var current = piece.Start;
-                foreach (var (start, end) in remove.Where(r => r.End > piece.Start && r.Start < piece.End))
-                {
-                    if (start > current + Tolerance.Epsilon)
-                        result.Add((current, start));
-                    current = System.Math.Max(current, end);
-                }
-                if (piece.End > current + Tolerance.Epsilon)
-                    result.Add((current, piece.End));
-            }
-            return result;
-        }
-
-        private static (CutOff Through, CutOff Stopper, double Point)? Junction(Plate plate, CutOff first, CutOff second)
-        {
-            if (first == second || first.Axis == second.Axis)
-                return null;
-            var firstAt = Line(second);
-            var secondAt = Line(first);
-            if (TouchesGap(first, firstAt) || TouchesGap(second, secondAt))
-                return null;
-            var (firstStart, firstEnd) = NominalSpan(plate, first);
-            var (secondStart, secondEnd) = NominalSpan(plate, second);
-            if (!Within(firstAt, firstStart, firstEnd) || !Within(secondAt, secondStart, secondEnd))
-                return null;
-            var firstStops = AtEnd(firstAt, firstStart, firstEnd);
-            var secondStops = AtEnd(secondAt, secondStart, secondEnd);
-            if (firstStops == secondStops)
-                return null;
-            return firstStops ? (second, first, secondAt) : (first, second, firstAt);
-        }
-
-        // Whether one of the cut-off's gaps contains or ends at the value along its axis.
-        private static bool TouchesGap(CutOff cutOff, double along) =>
-            cutOff.Gaps.Any(g => Within(along, g.Start, g.End));
-
-        // The limit an end takes when extended: the next crossing line beyond it, or null for the
-        // sheet edge. False when that end already runs to the sheet edge.
-        private static bool ExtendEnd(Plate plate, CutOff target, bool high, out double? limit)
-        {
-            limit = null;
-            if ((high ? target.EndLimit : target.StartLimit) == null)
-                return false;
-            var (start, end) = NominalSpan(plate, target);
-            var crossings = Crossings(plate, target);
-            if (high)
-            {
-                var next = crossings.Where(c => c > end + Tolerance.Epsilon).DefaultIfEmpty(double.NaN).Min();
-                limit = double.IsNaN(next) ? null : next;
-            }
-            else
-            {
-                var next = crossings.Where(c => c < start - Tolerance.Epsilon).DefaultIfEmpty(double.NaN).Max();
-                limit = double.IsNaN(next) ? null : next;
-            }
-            return true;
-        }
-
-        // Where the perpendicular cut-offs whose cut pieces reach this one cross it, along its axis.
-        private static List<double> Crossings(Plate plate, CutOff target)
-        {
-            var line = Line(target);
-            return plate.CutOffs
-                .Where(other => other != target && other.Axis != target.Axis)
-                .Where(other =>
-                {
-                    var (start, end) = NominalSpan(plate, other);
-                    return other.Pieces(start, end).Any(p => Within(line, p.Start, p.End));
-                })
-                .Select(Line)
-                .ToList();
-        }
-
-        // The change that leaves exactly the given pieces of the nominal line from start to end: a
-        // limit stays null while its end stays at the sheet edge.
-        private static CutOffLimitChange Change(CutOff target, double start, double end,
-            IReadOnlyList<(double Start, double End)> pieces)
-        {
-            var first = pieces[0].Start;
-            var last = pieces[^1].End;
-            return new CutOffLimitChange(target,
-                target.StartLimit == null && first == start ? null : first,
-                target.EndLimit == null && last == end ? null : last,
-                GapsBetween(pieces));
-        }
-
-        private static List<CutOffGap> GapsBetween(IReadOnlyList<(double Start, double End)> pieces)
-        {
-            var gaps = new List<CutOffGap>();
-            for (var i = 1; i < pieces.Count; i++)
-                if (pieces[i].Start > pieces[i - 1].End)
-                    gaps.Add(new CutOffGap(pieces[i - 1].End, pieces[i].Start));
-            return gaps;
-        }
-
-        private static CutOffEdit Single(Plate plate, CutOffLimitChange change) =>
-            CutOffEdit.Of(new[] { change }, Notice(plate, change));
-
-        private static string Notice(Plate plate, CutOffLimitChange change)
-        {
-            var cutOff = change.CutOff;
-            if (!(cutOff.HeadLockOvercut > 0))
-                return null;
-            var high = CutOff.FarEdgeIsHigh(cutOff.Axis, plate.Quadrant);
-            var before = (high ? cutOff.EndLimit : cutOff.StartLimit) == null;
-            var after = (high ? change.EndLimit : change.StartLimit) == null;
-            return before == after ? null : after ? OvercutOn : OvercutOff;
-        }
-
-        // The cut-off's own coordinate across its axis: X for a vertical line, Y for a horizontal one.
-        private static double Line(CutOff cutOff) =>
-            cutOff.Axis == CutOffAxis.Vertical ? cutOff.Position.X : cutOff.Position.Y;
-
-        private static double Along(CutOff cutOff, Vector point) =>
-            cutOff.Axis == CutOffAxis.Vertical ? point.Y : point.X;
-
-        private static double Distance(double value, (double Start, double End) piece) =>
-            value < piece.Start ? piece.Start - value : value > piece.End ? value - piece.End : 0;
-
-        private static bool Within(double value, double start, double end) =>
-            value >= start - Tolerance.Epsilon && value <= end + Tolerance.Epsilon;
-
-        private static bool AtEnd(double value, double start, double end) =>
-            System.Math.Abs(value - start) <= Tolerance.Epsilon || System.Math.Abs(value - end) <= Tolerance.Epsilon;
-    }
-}

OpenNest.Core/Diagnostics/ClampCutDiagnostics.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using OpenNest.Clamps;
-using OpenNest.CutOffs;
 using OpenNest.Geometry;
 
 namespace OpenNest.Diagnostics;
@@ -35,21 +33,15 @@ public static class ClampCutDiagnostics
             var farHigh = CutOff.FarEdgeIsHigh(cut.Axis, plate.Quadrant);
             var low = farHigh ? 0 : overcut;
             var high = farHigh ? overcut : 0;
-            var vertical = cut.Axis == CutOffAxis.Vertical;
+            var start = cut.Axis == CutOffAxis.Vertical
-            var from = cut.StartLimit ?? (vertical ? sheet.Bottom : sheet.Left) - low;
+                ? new Vector(cut.Position.X, cut.StartLimit ?? sheet.Bottom - low)
-            var to = cut.EndLimit ?? (vertical ? sheet.Top : sheet.Right) + high;
+                : new Vector(cut.StartLimit ?? sheet.Left - low, cut.Position.Y);
-            // A clamp wholly inside a gap meets no cut.
+            var end = cut.Axis == CutOffAxis.Vertical
+                ? new Vector(cut.Position.X, cut.EndLimit ?? sheet.Top + high)
+                : new Vector(cut.EndLimit ?? sheet.Right + high, cut.Position.Y);
             foreach (var zone in zones)
-                foreach (var (pieceStart, pieceEnd) in cut.Pieces(from, to))
+                if (Intersects(start, end, zone.Bounds, out var location))
-                {
+                    findings.Add(new CutOffClampFinding(index, zone.Id, location));
-                    var start = vertical ? new Vector(cut.Position.X, pieceStart) : new Vector(pieceStart, cut.Position.Y);
-                    var end = vertical ? new Vector(cut.Position.X, pieceEnd) : new Vector(pieceEnd, cut.Position.Y);
-                    if (Intersects(start, end, zone.Bounds, out var location))
-                    {
-                        findings.Add(new CutOffClampFinding(index, zone.Id, location));
-                        break;
-                    }
-                }
         }
         return findings.AsReadOnly();
     }

OpenNest.Core/Diagnostics/CommonLineReview.cs

@@ -1,203 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using OpenNest.CNC;
-using OpenNest.CNC.CuttingPlanning;
-using OpenNest.CommonLines;
-using OpenNest.Geometry;
-
-namespace OpenNest.Diagnostics;
-
-/// <summary>
-/// Pre-post review of a plate's common-line groups (<see cref="Plate.CommonLines"/>): every member
-/// still shares a span one kerf from another member, the group's kerf is still the plate's, and no
-/// member's lead or shared cut runs into a partner one kerf away (a lead on a shared edge would cut
-/// the partner). A plate that cuts its common lines once must cut each shared span exactly once, by
-/// the member cut first (its own compensated edge, or a centerline cut in older programs); one set
-/// to cut them twice must have no single-pass member programs.
-/// Reports only; nothing is repaired, and an unreadable lead check is incomplete, never clear.
-/// </summary>
-internal static class CommonLineReview
-{
-    internal static void Add(Plate plate, int plateNumber, List<PostVerificationFinding> findings,
-        CancellationToken token)
-    {
-        if (plate.CommonLines is not { Count: > 0 } groups)
-            return;
-        var plateKerf = plate.CuttingParameters?.Kerf is double k && double.IsFinite(k) && k > 0 ? k : (double?)null;
-        foreach (var group in groups)
-        {
-            token.ThrowIfCancellationRequested();
-            var first = Number(plate, group.Members[0]);
-            if (plateKerf is { } kerf && System.Math.Abs(kerf - group.Kerf) > CommonLineGeometry.GapTolerance)
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, first, null,
-                    $"Common line was placed for a {group.Kerf:0.####} kerf, but the plate now cuts with a "
-                    + $"{kerf:0.####} kerf. Rejoin the parts at the current kerf before posting."));
-            var check = CommonLineGeometry.Check(group);
-            foreach (var problem in check.Problems)
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, Number(plate, problem.Part), null,
-                    $"'{problem.Part.BaseDrawing.Name}' {problem.Message}")
-                { Location = problem.Part.BoundingBox?.Center });
-            Leads(plate, plateNumber, group, findings, token);
-            if (check.IsIntact)
-                SharedCuts(plate, plateNumber, group, check, findings, token);
-        }
-    }
-
-    // The shared cuts the members' programs make, against the spans the group derives now.
-    private static void SharedCuts(Plate plate, int plateNumber, CommonLineGroup group, CommonLineCheck check,
-        List<PostVerificationFinding> findings, CancellationToken token)
-    {
-        var cuts = new List<(Part Part, ExecutionMotion Motion)>();
-        Part singlePass = null;
-        foreach (var member in group.Members)
-        {
-            token.ThrowIfCancellationRequested();
-            if (singlePass == null && CommonLineCuts.IsSinglePass(member.Program))
-                singlePass = member;
-            try
-            {
-                cuts.AddRange(ExecutionMotionReader.Read(member.Program, member.Location, null, token).Motions
-                    .Where(motion => !motion.Rapid && motion.Curve != null
-                        && motion.Layer is LayerType.CommonLine or LayerType.Cut or LayerType.Display)
-                    .Select(motion => (member, motion)));
-            }
-            catch (Exception exception) when (IsInvalid(exception))
-            {
-                // The rapid check reports the unreadable program.
-            }
-        }
-        if (plate.CutCommonLinesTwice)
-        {
-            if (singlePass != null)
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, Number(plate, singlePass), null,
-                    "The plate is set to cut its common lines twice, but this part's program cuts a shared line "
-                    + "once. Plan cutting again before posting.")
-                { Location = singlePass.BoundingBox?.Center });
-            return;
-        }
-        foreach (var span in check.Spans)
-        {
-            token.ThrowIfCancellationRequested();
-            var covering = cuts.Where(cut => Covers(cut.Motion, span, group.Kerf)).ToList();
-            var first = Number(plate, span.First);
-            var second = Number(plate, span.Second);
-            var middle = (span.Start + span.End) * 0.5;
-            if (covering.Count == 0)
-            {
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, first, second,
-                    "This common line is not cut. Plan cutting cuts each shared line once; "
-                    + "or set the plate to cut its common lines twice.")
-                { Location = middle });
-                continue;
-            }
-            if (covering.Count > 1)
-            {
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, first, second,
-                    "This common line is cut more than once (a plate not planned since the parts were joined cuts "
-                    + "it twice). Plan cutting again before posting, or set the plate to cut its common lines twice.")
-                { Location = middle });
-                continue;
-            }
-            // The partner's remainder ends in this kerf, so the part that cuts it must come first.
-            var owner = covering[0].Part;
-            var partner = ReferenceEquals(owner, span.First) ? span.Second : span.First;
-            if (Number(plate, owner) is int o && Number(plate, partner) is int p && o > p)
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, o, p,
-                    "The shared line is cut after the partner whose remainder ends in its kerf. Plan cutting "
-                    + "again, or move the part that cuts it ahead of its partner.")
-                { Location = middle });
-        }
-    }
-
-    // A straight cut covering the whole span: a member's own compensated edge half a kerf off its
-    // centerline, or a centerline cut made without compensation.
-    private static bool Covers(ExecutionMotion motion, CommonLineSpan span, double kerf)
-    {
-        var curve = motion.Curve;
-        if (curve.IsFiniteArc)
-            return false;
-        var length = span.Length;
-        var along = (span.End - span.Start) * (1 / length);
-        double Offset(Vector point) => (point.X - span.Start.X) * along.Y - (point.Y - span.Start.Y) * along.X;
-        double At(Vector point) => (point.X - span.Start.X) * along.X + (point.Y - span.Start.Y) * along.Y;
-        var tolerance = CommonLineGeometry.GapTolerance;
-        var offset = Offset(curve.Start);
-        if (System.Math.Abs(Offset(curve.End) - offset) > tolerance)
-            return false;
-        var expected = motion.Layer == LayerType.CommonLine ? 0 : kerf / 2;
-        if (System.Math.Abs(System.Math.Abs(offset) - expected) > tolerance)
-            return false;
-        var from = System.Math.Min(At(curve.Start), At(curve.End));
-        var to = System.Math.Max(At(curve.Start), At(curve.End));
-        return from <= tolerance && to >= length - tolerance;
-    }
-
-    private static void Leads(Plate plate, int plateNumber, CommonLineGroup group,
-        List<PostVerificationFinding> findings, CancellationToken token)
-    {
-        var members = group.Members;
-        var materials = new LeadMaterialSnapshot[members.Count];
-        for (var i = 0; i < members.Count; i++)
-        {
-            token.ThrowIfCancellationRequested();
-            try
-            {
-                materials[i] = LeadMaterialSnapshot.Capture(FixedLeadReview.Clean(members[i]), members[i].Location, token);
-            }
-            catch (Exception exception) when (IsInvalid(exception))
-            {
-                materials[i] = null;
-            }
-            if (materials[i] is not { IsComplete: true })
-                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, Number(plate, members[i]), null,
-                    "Common-line lead check: " + (materials[i]?.Reason ?? "the clean material could not be captured.")));
-        }
-        for (var i = 0; i < members.Count; i++)
-        {
-            token.ThrowIfCancellationRequested();
-            if (materials[i] is not { IsComplete: true } own)
-                continue;
-            var partners = Enumerable.Range(0, members.Count)
-                .Where(j => j != i && materials[j] is { IsComplete: true }).ToArray();
-            OwnedExecution execution;
-            try
-            {
-                execution = ExecutionMotionReader.Read(members[i].Program, members[i].Location, null, token);
-            }
-            catch (Exception exception) when (IsInvalid(exception))
-            {
-                continue; // The rapid check reports the unreadable program.
-            }
-            var failures = new List<FixedLeadFailure>();
-            var result = LeadPathValidator.Check(execution, own, partners.Select(j => materials[j]).ToArray(),
-                _ => true, failures, token);
-            if (!result.IsComplete)
-                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, Number(plate, members[i]), null,
-                    "Common-line lead check: " + result.Reason));
-            // Only partners matter here: a lead into the part's own material is the lead checks' to report.
-            foreach (var failure in failures.Where(f => f.Obstacle is int))
-            {
-                var partner = members[partners[failure.Obstacle!.Value]];
-                var move = execution.Motions[failure.Motion];
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, Number(plate, members[i]),
-                    Number(plate, partner), move.Layer == LayerType.CommonLine
-                        ? $"A shared cut of '{members[i].BaseDrawing.Name}' runs into '{partner.BaseDrawing.Name}', its "
-                            + "common-line partner. Rejoin the parts one kerf apart and plan cutting again."
-                        : $"A lead of '{members[i].BaseDrawing.Name}' runs into '{partner.BaseDrawing.Name}', its "
-                            + "common-line partner one kerf away. Move the lead off the shared edge (Plan Cutting does).")
-                { Location = move.Curve?.Midpoint ?? move.End });
-            }
-        }
-    }
-
-    private static int? Number(Plate plate, Part part)
-    {
-        var index = plate.Parts.IndexOf(part);
-        return index < 0 ? null : index + 1;
-    }
-
-    private static bool IsInvalid(Exception exception) => exception is
-        ArgumentException or InvalidOperationException or NotSupportedException or ArithmeticException;
-}

OpenNest.Core/Diagnostics/OverlapGeometryStamp.cs

@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Clamps;
 using OpenNest.CNC;
-using OpenNest.CutOffs;
 
 namespace OpenNest.Diagnostics;
 
@@ -16,31 +12,20 @@ public sealed class OverlapGeometryStamp
     private readonly Plate plate;
     private readonly Entry[] entries;
     private readonly (string Id, long X, long Y, long Length, long Width)[] zones;
-    // Gaps are replaced, never edited in place, so their reference stands for their content.
+    private readonly (CutOff Definition, CutOffAxis Axis, long X, long Y, long? Start, long? End, long Overcut)[] cutoffs;
-    private readonly (CutOff Definition, CutOffAxis Axis, long X, long Y, long? Start, long? End,
-        IReadOnlyList<CutOffGap> Gaps, long Overcut)[] cutoffs;
     private readonly (long Width, long Length, int Quadrant) sheet;
-    private readonly long partSpacing;
-    private readonly string commonLines;
-    // The label also checks the sheet edge, so its spacing and outline make a result stale too.
-    private readonly (long Left, long Bottom, long Right, long Top) edgeSpacing;
-    private readonly SheetOutline outline;
 
     private OverlapGeometryStamp(Plate plate)
     {
         this.plate = plate;
         sheet = SheetState(plate);
-        partSpacing = Bits(plate.PartSpacing);
-        commonLines = CommonLineState(plate);
-        edgeSpacing = EdgeState(plate);
-        outline = plate.Outline;
         entries = new Entry[plate.Parts.Count];
         for (var i = 0; i < entries.Length; i++)
             entries[i] = new Entry(plate.Parts[i]);
         zones = new (string, long, long, long, long)[plate.ClampZones.Count];
         for (var i = 0; i < zones.Length; i++)
             zones[i] = ZoneState(plate.ClampZones[i]);
-        cutoffs = new (CutOff, CutOffAxis, long, long, long?, long?, IReadOnlyList<CutOffGap>, long)[plate.CutOffs.Count];
+        cutoffs = new (CutOff, CutOffAxis, long, long, long?, long?, long)[plate.CutOffs.Count];
         for (var i = 0; i < cutoffs.Length; i++)
             cutoffs[i] = CutOffState(plate.CutOffs[i]);
     }
@@ -51,22 +36,18 @@ public sealed class OverlapGeometryStamp
         zone?.Bounds is not { } box ? default
             : (zone.Id, Bits(box.X), Bits(box.Y), Bits(box.Length), Bits(box.Width));
 
-    private static (CutOff, CutOffAxis, long, long, long?, long?, IReadOnlyList<CutOffGap>, long) CutOffState(CutOff cut) =>
+    private static (CutOff, CutOffAxis, long, long, long?, long?, long) CutOffState(CutOff cut) =>
         cut == null ? default
             : (cut, cut.Axis, Bits(cut.Position.X), Bits(cut.Position.Y),
                 cut.StartLimit.HasValue ? Bits(cut.StartLimit.Value) : null,
                 cut.EndLimit.HasValue ? Bits(cut.EndLimit.Value) : null,
-                cut.Gaps, Bits(cut.HeadLockOvercut));
+                Bits(cut.HeadLockOvercut));
 
     private static long Bits(double value) => BitConverter.DoubleToInt64Bits(value);
 
     private static (long, long, int) SheetState(Plate plate) =>
         (Bits(plate.Size.Width), Bits(plate.Size.Length), plate.Quadrant);
 
-    private static (long, long, long, long) EdgeState(Plate plate) =>
-        (Bits(plate.EdgeSpacing.Left), Bits(plate.EdgeSpacing.Bottom), Bits(plate.EdgeSpacing.Right),
-            Bits(plate.EdgeSpacing.Top));
-
     public static OverlapGeometryStamp Capture(Plate plate) => new(plate);
 
     internal bool SameZones(Plate current)
@@ -93,25 +74,9 @@ public sealed class OverlapGeometryStamp
         return true;
     }
 
-    internal bool SameSpacing(Plate current) =>
-        ReferenceEquals(plate, current) && partSpacing == Bits(current.PartSpacing)
-        && commonLines == CommonLineState(current);
-
-    /// <summary>The same sheet, edge spacing and outline: an unchanged part keeps its edge finding.</summary>
-    internal bool SameSheet(Plate current) =>
-        ReferenceEquals(plate, current) && sheet == SheetState(current) && edgeSpacing == EdgeState(current)
-        && Equals(outline, current.Outline);
-
-    // Which plate slots share a common-line group, and its kerf: the spacing check reads both.
-    private static string CommonLineState(Plate plate) =>
-        string.Join(";", plate.CommonLines.Select(group => Bits(group.Kerf) + ":"
-            + string.Join(",", group.Members.Select(member => plate.Parts.IndexOf(member)))));
-
     public bool Matches(Plate current)
     {
-        if (current.Parts.Count != entries.Length || partSpacing != Bits(current.PartSpacing)
+        if (current.Parts.Count != entries.Length || !SameZones(current) || !SameCutOffs(current))
-            || commonLines != CommonLineState(current) || edgeSpacing != EdgeState(current)
-            || !Equals(outline, current.Outline) || !SameZones(current) || !SameCutOffs(current))
             return false;
         for (var i = 0; i < entries.Length; i++)
             if (!entries[i].Matches(current.Parts[i]))