docs(posts): describe CI Fiber M50 as Table In, the pallet swap

The pallet-change setting and post doc said M50 moves the cut sheet out,
borrowed from the CL-series manual. Cincinnati's CNC Codes Handbook calls
M50 "Table In" and M51 "Table Out". On the CI Fiber shuttle, Table In brings
the waiting pallet into the laser, which sends the cut one out, so M50 is
still the swap. Say that, note that it expects the waiting pallet to be
loaded, and note that newer Cincinnati samples end without a pallet code.
Default (M50) and posted output are unchanged.

.config/dotnet-tools.json

@@ -1,13 +0,0 @@
-{
-  "version": 1,
-  "isRoot": true,
-  "tools": {
-    "vpk": {
-      "version": "1.2.0",
-      "commands": [
-        "vpk"
-      ],
-      "rollForward": false
-    }
-  }
-}

.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:
@@ -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'
@@ -122,7 +114,8 @@ jobs:
   publish:
     if: >-
       github.repository == 'ajisaacs/OpenNest' &&
-      github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/master'
+      ((github.event_name == 'release' && github.event.release.prerelease == false) ||
+       (github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/master'))
     runs-on: ubuntu-latest
     timeout-minutes: 40
     permissions:

.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." }
           }
@@ -96,11 +96,6 @@ jobs:
           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: 14
           compression-level: 0

.gitignore

@@ -225,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

@@ -7,7 +7,7 @@ OpenNest is a .NET 8 Windows CNC-nesting application with cross-platform librari
 
 - Prefer Roslyn Bridge MCP for symbols, references and diagnostics when available; fall back to text search.
 - Use `var` for locals and namespaces matching project directories. Follow `.editorconfig`; format only changed C# files with `dotnet format OpenNest.sln --include <paths>`, then repeat with `--verify-no-changes`. On Linux, prefix both commands with `EnableWindowsTargeting=true`.
-- Keep instructions concise: commands, boundaries and non-obvious safeguards, not class inventories or session history. Update affected instructions and user-facing docs with behavior/build changes; put detailed contracts in `docs/`. User guides and their screenshots live in the separate `ajisaacs/opennest-help` repo: update or recapture them when a UI change alters a documented screen, and never rename a `HelpTopics` ID.
+- Keep instructions concise: commands, boundaries and non-obvious safeguards, not class inventories or session history. Update affected instructions and user-facing docs with behavior/build changes; put detailed contracts in `docs/`.
 - Never commit design specs, implementation plans, progress notes or temporary benchmark reports. Keep working records under local, ignored `.hermes/plans/` or `.hermes/progress/`; retain reusable verification procedures in `docs/`.
 - Keep vendor manuals/full-text extracts out of source control unless redistribution is authorized. Write project-specific behavior summaries with citations, separating controller rules, machine macros and unconfirmed behavior.
 
@@ -22,17 +22,13 @@ 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`.
-
-Only Plan Cutting changes need the [problem-nest corpus](docs/problem-nests.md) (`Category=ProblemNests`, opt-in via `OPENNEST_PROBLEM_NESTS_SERVER`); never run it for nesting engines, 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.
 
@@ -41,48 +37,33 @@ Releases: follow [the release procedure](docs/releasing.md) and `scripts/Publish
 - `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 the desktop output's `Posts/` directory. 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`. Posts live in `Posts/OpenNest.Posts.<Name>/` and deploy to the desktop output's `Posts/` directory.
-- `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
 
 - Marks are not material: use `SpecialLayers.IsMaterial` when deriving nesting/collision geometry; exclude rapid and scribe moves without removing them from display, cutting time or posts.
-- Engine/validator collision paths retain the hand-written `Collision` kernel; its GPU port is on hold. Material-overlap diagnostics use Clipper2 per pair for connected shared-material islands and interior markers; see [material-overlap diagnostics](docs/geometry/visual-overlap-check.md). Polygon consumers use `ClipperBridge`; directional-distance consumers retain native-arc offsets. Validation uses `OffsetForValidation` and `NestTolerances.SpacingSlack`, not conservative display/preparation padding; Auto Nest's layout check, the runner's candidate validation and the pre-post part-spacing review all find spacing candidates with Core's `SpacingOutline` and confirm them on `NativeContours` (the outline circumscribes arcs by more than the slack), so they agree; `NestLayoutCheck.Clears` skips the confirmation and stays stricter for engine certification. Do not loosen tolerances to hide failures.
+- Engine/validator collision paths retain the hand-written `Collision` kernel; its GPU port is on hold. Material-overlap diagnostics use Clipper2 per pair for connected shared-material islands and interior markers; see [material-overlap diagnostics](docs/geometry/visual-overlap-check.md). Polygon consumers use `ClipperBridge`; directional-distance consumers retain native-arc offsets. Validation uses `OffsetForValidation` and `NestTolerances.SpacingSlack`, not conservative display/preparation padding; Auto Nest's layout check and the pre-post part-spacing review share Core's `SpacingOutline` for candidates; the review then confirms each one on finely flattened native contours, so it never warns where Auto Nest's check would pass. Do not loosen tolerances to hide failures.
 - `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) 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
-- [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 (owner first, open `CommonLine` centerline cut, then each member's remainder) 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, and Plan Cutting's tab placement for parts 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
-- [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): Velopack feed, `UpdateFeedUrl` setting 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.

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

@@ -1,9 +0,0 @@
-<Application xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             x:Class="OpenNest.Avalonia.App"
-             RequestedThemeVariant="Light">
-  <Application.Styles>
-    <FluentTheme />
-    <StyleInclude Source="avares://Avalonia.Controls.DataGrid/Themes/Fluent.xaml" />
-  </Application.Styles>
-</Application>

OpenNest.Avalonia/App.axaml.cs

@@ -1,33 +0,0 @@
-using Avalonia;
-using Avalonia.Controls.ApplicationLifetimes;
-using Avalonia.Markup.Xaml;
-
-namespace OpenNest.Avalonia
-{
-    public partial class App : Application
-    {
-        public override void Initialize() => AvaloniaXamlLoader.Load(this);
-
-        public override void OnFrameworkInitializationCompleted()
-        {
-            if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-            {
-                var window = new MainWindow();
-                desktop.MainWindow = window;
-                var args = desktop.Args ?? System.Array.Empty<string>();
-                if (args.Length > 0)
-                    window.OpenNest(args[0]);
-                // --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);
-            }
-
-            base.OnFrameworkInitializationCompleted();
-        }
-    }
-}

OpenNest.Avalonia/Controls/PlateCanvas.cs

@@ -1,388 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Avalonia;
-using Avalonia.Input;
-using Avalonia.Media;
-using Avalonia.Platform;
-using Avalonia.Rendering.SceneGraph;
-using Avalonia.Skia;
-using OpenNest.Avalonia.Rendering;
-using OpenNest.CNC;
-using OpenNest.Geometry;
-using SkiaSharp;
-using Control = Avalonia.Controls.Control;
-using Vector = OpenNest.Geometry.Vector;
-
-namespace OpenNest.Avalonia.Controls
-{
-    /// <summary>
-    /// Draws one plate with Skia: 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
-    {
-        private static readonly SKColor BackgroundColor = new(169, 169, 169);
-        private static readonly SKColor PlateFillColor = new(245, 245, 245);
-        private static readonly SKColor PlateOutlineColor = new(128, 128, 128);
-        private static readonly SKColor EdgeSpacingColor = new(180, 180, 180);
-        private static readonly SKColor LeadColor = new(255, 0, 0);
-        private static readonly SKColor EtchColor = new(0, 150, 60);
-        private static readonly SKColor SelectedColor = new(150, 200, 255, 90 * 255 / 100);
-
-        // 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;
-
-        public Plate Plate
-        {
-            get => plate;
-            set
-            {
-                plate = value;
-                HoveredPart = null;
-                SelectedPart = null;
-                fitPending = true;
-                InvalidateVisual();
-            }
-        }
-
-        public Part HoveredPart { get; private set; }
-
-        public Part SelectedPart { get; private set; }
-
-        /// <summary>The cursor in plate coordinates, or null when it is outside the view.</summary>
-        public Vector? CursorWorld { get; private set; }
-
-        public event EventHandler ViewChanged;
-
-        public PlateCanvas()
-        {
-            ClipToBounds = true;
-            Focusable = true;
-        }
-
-        public void ClearCache() => paths.Clear();
-
-        public void ZoomToFit()
-        {
-            if (!Fit())
-                return;
-            InvalidateVisual();
-            ViewChanged?.Invoke(this, EventArgs.Empty);
-        }
-
-        /// <summary>Fits the view to the plate and its parts without requesting a redraw.</summary>
-        private bool Fit()
-        {
-            if (plate == null || Bounds.Width <= 0 || Bounds.Height <= 0)
-                return false;
-            var extents = PlateRect(plate);
-            foreach (var part in plate.Parts)
-                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;
-        }
-
-        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)scale, 0, (float)origin.X, 0, (float)-scale, (float)origin.Y, 0, 0, 1);
-
-        private static Box PlateRect(Plate plate)
-        {
-            var left = plate.Quadrant is 2 or 3 ? -plate.Size.Length : 0;
-            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;
-        }
-
-        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));
-
-            var items = new List<PartItem>();
-            if (plate != null)
-            {
-                for (var i = 0; i < plate.Parts.Count; i++)
-                {
-                    var part = plate.Parts[i];
-                    items.Add(new PartItem(PathsFor(part), part.Location, part.BoundingBox,
-                        ToSkColor(part.BaseDrawing.Color), (i + 1).ToString(),
-                        ReferenceEquals(part, SelectedPart), ReferenceEquals(part, HoveredPart),
-                        part.BaseDrawing.IsCutOff, part.HasManualLeadIns));
-                }
-            }
-
-            context.Custom(new PlateDrawOperation(new Rect(Bounds.Size), plate == null ? null : PlateRect(plate),
-                plate?.EdgeSpacing, WorldMatrix, items));
-        }
-
-        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);
-            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;
-        }
-
-        protected override void OnPointerPressed(PointerPressedEventArgs e)
-        {
-            Focus();
-            var point = e.GetCurrentPoint(this);
-            if (e.ClickCount == 2)
-            {
-                ZoomToFit();
-                return;
-            }
-            if (point.Properties.IsLeftButtonPressed)
-            {
-                SelectedPart = HitTest(ToWorld(point.Position));
-                InvalidateVisual();
-                ViewChanged?.Invoke(this, EventArgs.Empty);
-            }
-            if (point.Properties.IsLeftButtonPressed || point.Properties.IsMiddleButtonPressed)
-            {
-                dragStart = point.Position;
-                e.Pointer.Capture(this);
-            }
-        }
-
-        protected override void OnPointerMoved(PointerEventArgs e)
-        {
-            var at = e.GetPosition(this);
-            if (dragStart is { } start)
-            {
-                origin += at - start;
-                dragStart = at;
-                InvalidateVisual();
-            }
-
-            CursorWorld = ToWorld(at);
-            var hovered = dragStart == null ? HitTest(CursorWorld.Value) : HoveredPart;
-            if (!ReferenceEquals(hovered, HoveredPart))
-            {
-                HoveredPart = hovered;
-                InvalidateVisual();
-            }
-            ViewChanged?.Invoke(this, EventArgs.Empty);
-        }
-
-        protected override void OnPointerReleased(PointerReleasedEventArgs e)
-        {
-            dragStart = null;
-            e.Pointer.Capture(null);
-        }
-
-        protected override void OnPointerExited(PointerEventArgs e)
-        {
-            CursorWorld = null;
-            if (HoveredPart != null)
-            {
-                HoveredPart = null;
-                InvalidateVisual();
-            }
-            ViewChanged?.Invoke(this, EventArgs.Empty);
-        }
-
-        protected override void OnKeyDown(KeyEventArgs e)
-        {
-            if (e.Key == Key.F)
-            {
-                ZoomToFit();
-                e.Handled = true;
-            }
-        }
-
-        protected override void OnSizeChanged(global::Avalonia.Controls.SizeChangedEventArgs e)
-        {
-            base.OnSizeChanged(e);
-            if (fitPending)
-                InvalidateVisual();
-        }
-
-        /// <summary>The topmost part whose material contains <paramref name="world"/>.</summary>
-        private Part HitTest(Vector world)
-        {
-            if (plate == null)
-                return null;
-            for (var i = plate.Parts.Count - 1; i >= 0; i--)
-            {
-                var part = plate.Parts[i];
-                var box = part.BoundingBox;
-                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).Fill.Contains((float)local.X, (float)local.Y))
-                    return part;
-            }
-            return null;
-        }
-
-        private sealed record PartItem(ProgramPaths Paths, Vector Location, Box Bounds, SKColor Color,
-            string Label, bool Selected, bool Hovered, bool IsCutOff, bool ShowLeads);
-
-        private sealed class PlateDrawOperation : ICustomDrawOperation
-        {
-            private readonly Box plateRect;
-            private readonly Spacing? edgeSpacing;
-            private readonly SKMatrix matrix;
-            private readonly List<PartItem> items;
-
-            public PlateDrawOperation(Rect bounds, Box plateRect, Spacing? edgeSpacing, SKMatrix matrix,
-                List<PartItem> items)
-            {
-                Bounds = bounds;
-                this.plateRect = plateRect;
-                this.edgeSpacing = edgeSpacing;
-                this.matrix = matrix;
-                this.items = items;
-            }
-
-            public Rect Bounds { get; }
-
-            public bool HitTest(Point p) => Bounds.Contains(p);
-
-            public bool Equals(ICustomDrawOperation other) => false;
-
-            public void Dispose()
-            {
-            }
-
-            public void Render(ImmediateDrawingContext context)
-            {
-                var lease = context.TryGetFeature<ISkiaSharpApiLeaseFeature>();
-                if (lease == null)
-                    return;
-                using var api = lease.Lease();
-                var canvas = api.SkCanvas;
-                canvas.Save();
-                canvas.ClipRect(new SKRect(0, 0, (float)Bounds.Width, (float)Bounds.Height));
-                canvas.Clear(BackgroundColor);
-
-                if (plateRect != null)
-                    Draw(canvas);
-
-                canvas.Restore();
-            }
-
-            private void Draw(SKCanvas canvas)
-            {
-                // Hairline strokes (width 0) stay one pixel wide at any zoom.
-                using var fill = new SKPaint { Style = SKPaintStyle.Fill, IsAntialias = true };
-                using var stroke = new SKPaint { Style = SKPaintStyle.Stroke, StrokeWidth = 0, IsAntialias = true };
-
-                canvas.Save();
-                var world = matrix;
-                canvas.Concat(ref world);
-
-                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)
-                {
-                    stroke.Color = EdgeSpacingColor;
-                    canvas.DrawRect(new SKRect(plate.Left + (float)spacing.Left,
-                        plate.Top + (float)spacing.Bottom, plate.Right - (float)spacing.Right,
-                        plate.Bottom - (float)spacing.Top), stroke);
-                }
-                stroke.Color = PlateOutlineColor;
-                canvas.DrawRect(plate, stroke);
-
-                var view = canvas.LocalClipBounds;
-                foreach (var item in items)
-                {
-                    var b = item.Bounds;
-                    if (b.Right < view.Left || b.Left > view.Right || b.Top < view.Top || b.Bottom > view.Bottom)
-                        continue;
-
-                    canvas.Save();
-                    canvas.Translate((float)item.Location.X, (float)item.Location.Y);
-
-                    fill.Color = item.Selected ? SelectedColor
-                        : item.Hovered ? Lighten(item.Color) : item.Color;
-                    canvas.DrawPath(item.Paths.Fill, fill);
-
-                    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 center = matrix.MapPoint((float)item.Bounds.Center.X, (float)item.Bounds.Center.Y);
-                    var width = item.Bounds.Length * matrix.ScaleX;
-                    var height = item.Bounds.Width * -matrix.ScaleY;
-                    var measured = text.MeasureText(item.Label);
-                    if (measured + 4 > width || text.TextSize + 4 > height)
-                        continue;
-                    canvas.DrawText(item.Label, center.X - measured / 2, center.Y + text.TextSize / 3, text);
-                }
-            }
-
-            private static SKColor Darken(SKColor c) =>
-                new((byte)(c.Red * 0.55), (byte)(c.Green * 0.55), (byte)(c.Blue * 0.55), 255);
-
-            private static SKColor Lighten(SKColor c) =>
-                new((byte)(c.Red + (255 - c.Red) / 2), (byte)(c.Green + (255 - c.Green) / 2),
-                    (byte)(c.Blue + (255 - c.Blue) / 2), c.Alpha);
-        }
-    }
-}

OpenNest.Avalonia/MainWindow.axaml

@@ -1,60 +0,0 @@
-<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="OpenMenuItem" Header="_Open..." InputGesture="Ctrl+O" Click="OnOpen" />
-        <Separator />
-        <MenuItem Header="E_xit" Click="OnExit" />
-      </MenuItem>
-      <MenuItem Header="_Nest">
-        <MenuItem x:Name="AutoNestMenuItem" Header="_Auto Nest" Click="OnAutoNest" />
-      </MenuItem>
-      <MenuItem Header="_View">
-        <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" />
-      </MenuItem>
-    </Menu>
-
-    <Border DockPanel.Dock="Top" Padding="4" BorderThickness="0,0,0,1" BorderBrush="#D0D0D0">
-      <StackPanel Orientation="Horizontal" Spacing="4">
-        <Button x:Name="OpenButton" Content="Open" Click="OnOpen" />
-        <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="Open a .nest file to begin." />
-    </Border>
-
-    <Grid ColumnDefinitions="260,4,*,4,320">
-      <DockPanel Grid.Column="0">
-        <TextBlock DockPanel.Dock="Top" Margin="6,6,6,2" FontWeight="SemiBold" Text="Plates" />
-        <ListBox x:Name="PlateList" SelectionChanged="OnPlateSelected" />
-      </DockPanel>
-      <GridSplitter Grid.Column="1" ResizeDirection="Columns" />
-      <c:PlateCanvas Grid.Column="2" x:Name="Canvas" />
-      <GridSplitter Grid.Column="3" ResizeDirection="Columns" />
-      <DockPanel Grid.Column="4">
-        <TextBlock DockPanel.Dock="Top" Margin="6,6,6,2" FontWeight="SemiBold" Text="Drawings on plate" />
-        <DataGrid x:Name="DrawingGrid" x:DataType="local:DrawingRow" IsReadOnly="True"
-                  AutoGenerateColumns="False" GridLinesVisibility="Horizontal" CanUserSortColumns="True">
-          <DataGrid.Columns>
-            <DataGridTextColumn Header="Drawing" Binding="{Binding Name}" Width="*" />
-            <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,255 +0,0 @@
-using System;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Avalonia.Controls;
-using Avalonia.Input;
-using Avalonia.Interactivity;
-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 Document document;
-        private string fileName;
-        private string notice;
-        private CancellationTokenSource nesting;
-        private Task autoNest = Task.CompletedTask;
-
-        private Nest nest => document?.Nest;
-
-        public MainWindow()
-        {
-            InitializeComponent();
-            // As the desktop app: plug-in engines first, then the saved engine selection.
-            NestingEngineRegistry.LoadPlugins(Path.Combine(AppContext.BaseDirectory, "Engines"));
-            var engineWarning = EngineSelection.LoadSavedSelection();
-            if (!string.IsNullOrEmpty(engineWarning))
-                notice = engineWarning;
-            Canvas.ViewChanged += (_, _) => UpdateStatus();
-            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.PageUp), Command = new Command(() => StepPlate(-1)) });
-            KeyBindings.Add(new KeyBinding { Gesture = new KeyGesture(Key.PageDown), Command = new Command(() => StepPlate(1)) });
-        }
-
-        public void OpenNest(string path)
-        {
-            if (nesting != null)
-                return;
-            try
-            {
-                document = new Document { Nest = new NestReader(path).Read() };
-            }
-            catch (Exception ex)
-            {
-                Status.Text = $"Could not open {Path.GetFileName(path)}: {ex.Message}";
-                return;
-            }
-
-            fileName = Path.GetFileName(path);
-            Title = $"{fileName} - OpenNest (Avalonia prototype)";
-            notice = null;
-            Canvas.ClearCache();
-            RefreshPlateList(0);
-        }
-
-        private void RefreshPlateList(int selectIndex)
-        {
-            PlateList.ItemsSource = nest.Plates
-                .Select((plate, i) => $"Plate {i + 1}   {plate.Size.Length:0.###} x {plate.Size.Width:0.###}   ({plate.Parts.Count} parts)")
-                .ToList();
-            PlateList.SelectedIndex = nest.Plates.Count > 0 ? System.Math.Clamp(selectIndex, 0, nest.Plates.Count - 1) : -1;
-        }
-
-        /// <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)
-        {
-            Opened += async (_, _) =>
-            {
-                if (nest?.Plates.Count > 0)
-                    PlateList.SelectedIndex = System.Math.Clamp(plateNumber - 1, 0, nest.Plates.Count - 1);
-                await autoNest;
-                await System.Threading.Tasks.Task.Delay(500);
-                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);
-                Close();
-            };
-        }
-
-        private async void OnOpen(object sender, RoutedEventArgs e)
-        {
-            if (nesting != null)
-                return;
-            var files = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
-            {
-                Title = "Open Nest",
-                AllowMultiple = false,
-                FileTypeFilter = new[] { new FilePickerFileType("Nest files") { Patterns = new[] { "*.nest" } } },
-            });
-            var path = files.FirstOrDefault()?.TryGetLocalPath();
-            if (path != null)
-                OpenNest(path);
-        }
-
-        private void OnExit(object sender, RoutedEventArgs e) => Close();
-
-        private void OnAutoNest(object sender, RoutedEventArgs e)
-        {
-            // Stop always cancels and discards the whole proposal.
-            if (nesting != null)
-            {
-                nesting.Cancel();
-                return;
-            }
-            autoNest = RunAutoNestAsync();
-        }
-
-        /// <summary>
-        /// Nests every drawing's remaining quantity on sheets like the shown plate through the
-        /// shared pipeline, off the UI thread. Open is refused until it finishes, so the nest
-        /// and its drawings stay stable from the request to the commit.
-        /// </summary>
-        private async Task RunAutoNestAsync()
-        {
-            if (nest == null || nesting != null)
-                return;
-            var engineName = EngineSelection.EngineName;
-            var template = Canvas.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();
-            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)
-                    RefreshPlateList(firstNew);
-                ShowNotice(kept.Nested ? $"{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;
-                SetNesting(false);
-            }
-        }
-
-        private void SetNesting(bool running)
-        {
-            AutoNestButton.Content = running ? "Stop" : "Auto Nest";
-            AutoNestMenuItem.Header = running ? "_Stop Auto Nest" : "_Auto Nest";
-            OpenButton.IsEnabled = !running;
-            OpenMenuItem.IsEnabled = !running;
-        }
-
-        private void ShowNotice(string text)
-        {
-            notice = text;
-            UpdateStatus();
-            if (Canvas.Plate == null)
-                Status.Text = text;
-        }
-
-        private void OnFit(object sender, RoutedEventArgs e) => Canvas.ZoomToFit();
-
-        private void OnPreviousPlate(object sender, RoutedEventArgs e) => StepPlate(-1);
-
-        private void OnNextPlate(object sender, RoutedEventArgs e) => StepPlate(1);
-
-        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()
-        {
-            if (Canvas.Plate == null)
-                return;
-            var text = $"{fileName}   Plate {PlateList.SelectedIndex + 1} of {nest.Plates.Count}   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;
-            if (part != null)
-                text += $"   {(ReferenceEquals(part, Canvas.SelectedPart) ? "Selected" : "Over")}: {part.BaseDrawing.Name}";
-            if (notice != null)
-                text += $"   |   {notice}";
-            Status.Text = text;
-        }
-
-        private sealed class Command : System.Windows.Input.ICommand
-        {
-            private readonly Action action;
-
-            public Command(Action action) => this.action = action;
-
-            public event EventHandler CanExecuteChanged { add { } remove { } }
-
-            public bool CanExecute(object parameter) => true;
-
-            public void Execute(object parameter) => action();
-        }
-    }
-}

OpenNest.Avalonia/OpenNest.Avalonia.csproj

@@ -1,21 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
-    <RootNamespace>OpenNest.Avalonia</RootNamespace>
-    <AssemblyName>OpenNest.Avalonia</AssemblyName>
-    <Nullable>disable</Nullable>
-    <BuiltInComInteropSupport>true</BuiltInComInteropSupport>
-    <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-  </PropertyGroup>
-  <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>
-</Project>

OpenNest.Avalonia/Program.cs

@@ -1,18 +0,0 @@
-using System;
-using Avalonia;
-
-namespace OpenNest.Avalonia
-{
-    internal static class Program
-    {
-        [STAThread]
-        public static void Main(string[] args) =>
-            BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
-
-        public static AppBuilder BuildAvaloniaApp() =>
-            AppBuilder.Configure<App>()
-                .UsePlatformDetect()
-                .WithInterFont()
-                .LogToTrace();
-    }
-}

OpenNest.Avalonia/Rendering/ProgramPaths.cs

@@ -1,175 +0,0 @@
-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.Benchmark/BenchmarkJob.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -38,19 +37,9 @@ namespace OpenNest.Benchmark
         public double PartSpacing { get; init; }
         public int Quadrant { get; init; }
 
-        /// <summary>Source plate's machine clamp rail, resolved for each candidate size as Auto Nest does; null when none.</summary>
-        public ClampRail ClampRail { get; init; }
-
-        /// <summary>Source plate's explicit clamp zones when it has no rail, offered unchanged on every size.</summary>
-        public IReadOnlyList<ClampZone> ClampZones { get; init; } = Array.Empty<ClampZone>();
-
         /// <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; }
@@ -71,8 +60,7 @@ namespace OpenNest.Benchmark
         /// (unlimited quantity - the engine under test decides how many of each
         /// size it actually uses, and how demand splits across plates). The
         /// engine owns its own multi-plate/size strategy; this harness no
-        /// longer picks plate sizes on the engine's behalf. Stock comes from
+        /// longer picks plate sizes on the engine's behalf.
-        /// the same template builder as desktop Auto Nest, so clamps match it.
         /// </summary>
         public NestJob BuildNestJob(
             int maxPlates,
@@ -83,41 +71,24 @@ namespace OpenNest.Benchmark
             var parts = Requests.Select(r =>
                 DrawingJobMapper.FromDrawing(r.Drawing.Id.ToString(), r.Drawing, r.Quantity)
             );
-            // No options would make the builder offer the template itself; an empty pool stays empty.
+            var stock = CandidateSizes.Select(size => new NestPlateStock(
-            var stock = CandidateSizes.Count == 0
+                size.ToString(1),
-                ? Array.Empty<NestPlateStock>()
+                size,
-                : NestStockBuilder.FromTemplate(
+                null,
-                    StockTemplate(),
+                PartSpacing,
-                    CandidateSizes.Select(size => new PlateOption { Width = size.Width, Length = size.Length }).ToList()
+                EdgeSpacing,
-                );
+                Quadrant
+            ));
             return new NestJob(
                 parts,
                 stock,
                 new NestJobOptions(
-                    "Lattice",
+                    "Fill",
                     maxPlates,
                     salvageRate ?? SalvageRate,
-                    minimumSalvageDimension ?? 0,
+                    minimumSalvageDimension ?? 0
-                    offcutCut: OffcutCut
                 )
             );
         }
-
-        /// <summary>A plate carrying this job's spacing, quadrant and clamps, sized to the largest candidate.</summary>
-        private Plate StockTemplate()
-        {
-            var template = new Plate(CandidateSizes.MaxBy(size => size.Width * size.Length))
-            {
-                PartSpacing = PartSpacing,
-                EdgeSpacing = EdgeSpacing,
-                Quadrant = Quadrant,
-            };
-            if (ClampRail != null)
-                template.SetClampRail(ClampRail);
-            else
-                foreach (var zone in ClampZones)
-                    template.ClampZones.Add(zone);
-            return template;
-        }
     }
 }

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
                     )
             );
 
@@ -140,7 +126,14 @@ namespace OpenNest.Benchmark
                     .BaselinePlateRuns.Select(
                         (run, index) =>
                         {
-                            var stock = DrawingJobMapper.FromPlate($"baseline-{index}", run.Plate, 1);
+                            var stock = new NestPlateStock(
+                                $"baseline-{index}",
+                                run.Plate.Size,
+                                1,
+                                run.Plate.PartSpacing,
+                                run.Plate.EdgeSpacing,
+                                run.Plate.Quadrant
+                            );
                             var placements = run
                                 .Parts.Select(part =>
                                 {
@@ -228,22 +221,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 +241,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 +363,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 +375,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,28 +0,0 @@
-using System.Linq;
-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

@@ -52,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
@@ -150,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;
@@ -177,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; }
         }
 
@@ -230,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

@@ -74,8 +74,6 @@ namespace OpenNest.Benchmark
                         EdgeSpacing = template.EdgeSpacing,
                         PartSpacing = partSpacingOverride ?? template.PartSpacing,
                         Quadrant = template.Quadrant,
-                        ClampRail = template.ClampRail,
-                        ClampZones = template.ClampZones,
                         SalvageRate = nest.SalvageRate,
                         BaselinePlateRuns = BuildBaselinePlateRuns(nest, partSpacingOverride),
                         Requests = requests,
@@ -184,45 +182,23 @@ namespace OpenNest.Benchmark
                         plate.EdgeSpacing.Top
                     ),
                 };
-                // Clamps are part of the sheet the layout was made on.
-                if (plate.ClampRail != null)
-                    validationPlate.SetClampRail(plate.ClampRail, plate.RemovedClamps);
-                else
-                    foreach (var zone in plate.ClampZones)
-                        validationPlate.ClampZones.Add(zone);
                 for (var copy = 0; copy < plate.Quantity; copy++)
                     runs.Add((validationPlate, parts));
             }
             return runs.Count > 0 ? runs : null;
         }
 
-        private static (
+        private static (Spacing EdgeSpacing, double PartSpacing, int Quadrant) ResolvePlateTemplate(
-            Spacing EdgeSpacing,
+            Nest nest
-            double PartSpacing,
+        )
-            int Quadrant,
-            ClampRail ClampRail,
-            IReadOnlyList<ClampZone> ClampZones
-        ) ResolvePlateTemplate(Nest nest)
         {
             var source = nest.Plates?.FirstOrDefault();
 
             if (source != null)
-                return (
+                return (source.EdgeSpacing, source.PartSpacing, source.Quadrant);
-                    source.EdgeSpacing,
-                    source.PartSpacing,
-                    source.Quadrant,
-                    source.ClampRail,
-                    source.ClampRail == null ? source.ClampZones.ToList() : Array.Empty<ClampZone>()
-                );
 
             var defaults = nest.PlateDefaults;
-            return (
+            return (defaults.EdgeSpacing, defaults.PartSpacing, defaults.Quadrant);
-                defaults.EdgeSpacing,
-                defaults.PartSpacing,
-                defaults.Quadrant,
-                defaults.ClampRail,
-                Array.Empty<ClampZone>()
-            );
         }
 
         private static List<Size> ResolveSheetSizes(Nest nest)

OpenNest.Benchmark/Program.cs

@@ -18,9 +18,6 @@ static class BenchmarkConsole
         if (options == null)
             return 0; // --help was requested
 
-        if (options.Invalid)
-            return 1;
-
         if (options.InputPath == null)
         {
             PrintUsage();
@@ -127,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);
@@ -202,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;
@@ -238,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;
     }
 
@@ -280,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(
@@ -391,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");
     }
 
@@ -424,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)
@@ -118,7 +115,7 @@ static class NestConsole
                 Console.Error.WriteLine(
                     engine.IsJobEngine
                         ? $"Error: engine '{engine.Name}' is a whole-job engine; single-plate fill supports: {string.Join(", ", PlateFillService.BuiltInStrategies)}. Use --autonest for whole-job engines."
-                        : $"Error: unknown engine '{engine.Name}'. Fill strategies: {string.Join(", ", PlateFillService.BuiltInStrategies)} (whole-job engines such as Irregular require --autonest)"
+                        : $"Error: unknown engine '{engine.Name}'. Fill strategies: {string.Join(", ", PlateFillService.BuiltInStrategies)} (whole-job engines such as StockLadder require --autonest)"
                 );
                 return 1;
             }
@@ -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)
     {
@@ -900,7 +824,6 @@ static class NestConsole
             {
                 CuttingPlanPhase.Reordering => "finding a part order...",
                 CuttingPlanPhase.KeepingOrder => "keeping the current order...",
-                CuttingPlanPhase.SafestRoute => "finding the safest route...",
                 CuttingPlanPhase.CheckingOverlap => "checking for overlaps...",
                 _ => value.Phase + "...",
             });
@@ -1013,17 +936,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 +980,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 +989,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 +1003,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 +1036,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 +1058,5 @@ static class NestConsole
         public bool AllPlates;
         public double? RepairBendsMillimeters;
         public BendRepairUnits CadUnits;
-        public double? SvgUnitsPerInch;
     }
 }

OpenNest.Core/AutomaticCutOffPlanner.cs

@@ -27,14 +27,6 @@ public sealed class AutomaticCutOffOptions
     /// Otherwise must be finite, greater than MinimumSpacing and no greater than Spacing.
     /// </summary>
     public double? MinimumStripLength { get; set; }
-
-    /// <summary>
-    /// Whether to propose a full-length horizontal separator that keeps the unused band beyond the
-    /// parts along Y (away from the origin) when that band is a larger piece than the X tail.
-    /// The band must be at least MinimumTailLength wide. False preserves vertical-only proposals.
-    /// An existing full-length horizontal cut-off clear of the parts is honored either way.
-    /// </summary>
-    public bool KeepHorizontalRemnant { get; set; }
 }
 
 public enum AutomaticCutOffDiagnosticCode
@@ -47,9 +39,6 @@ public enum AutomaticCutOffDiagnosticCode
     NoSafeTailSeparator,
     TailBelowMinimum,
     ShiftedCut,
-    HorizontalRemnant,
-    NoSafeHorizontalSeparator,
-    ClampMovedTailSeparator,
 }
 
 public sealed record AutomaticCutOffDiagnostic(
@@ -88,15 +77,6 @@ public sealed class AutomaticCutOffPlan
     /// <summary>True only for a verified full-width separator, never just a nominal boundary.</summary>
     public bool HasSeparatedTail => TailSeparatorX.HasValue;
 
-    /// <summary>
-    /// Signed Y coordinate of the new or existing full-length horizontal separator the vertical
-    /// lines stop at, keeping the band beyond it; null when the lines cross the full sheet width.
-    /// </summary>
-    public double? HorizontalSeparatorY { get; internal set; }
-
-    /// <summary>Width along Y of the band kept beyond HorizontalSeparatorY, otherwise zero.</summary>
-    public double HorizontalRemnantWidth { get; internal set; }
-
     /// <summary>Total cut length of proposed new strip lines (excludes the tail separator).</summary>
     public double StripCutLength { get; internal set; }
 
@@ -110,15 +90,6 @@ public sealed class AutomaticCutOffPlan
 public static class AutomaticCutOffPlanner
 {
     public const double GeometryTolerance = Tolerance.Epsilon;
-
-    /// <summary>
-    /// How far a display perimeter (a supplied blank's never-cut outline) may extend past the
-    /// physical sheet, in model units. Imported blanks equal their sheet but carry the source CAM's
-    /// rounding (PEP: a 0.000006 outline skew plus placements rounded to 0.001), a few hundred-
-    /// thousandths of an inch. Nothing cuts that outline, so it is accepted; anything cut, or a
-    /// larger overhang that signals a real placement error, is still refused.
-    /// </summary>
-    public const double DisplayPerimeterSheetAllowance = 1e-4;
     public const double MinimumSpacing = 2 * GeometryTolerance;
     public const int MaximumCandidateCount = 10000;
     public const int MaximumShiftCandidateCount = 20000;
@@ -144,9 +115,7 @@ public static class AutomaticCutOffPlanner
             "Physical sheet bounds and overtravel must be finite.", nameof(plate));
 
         var sign = plate.Quadrant is 2 or 3 ? -1 : 1;
-        var ySign = plate.Quadrant is 3 or 4 ? -1 : 1;
         var occupied = 0.0;
-        var occupiedY = 0.0;
         var hasParts = false;
         foreach (var part in plate.Parts)
         {
@@ -154,9 +123,7 @@ public static class AutomaticCutOffPlanner
             if (part.BaseDrawing.IsCutOff)
                 continue;
 
-            var (partX, partY) = ValidatePart(part, bounds, sign, ySign);
+            occupied = System.Math.Max(occupied, ValidatePart(part, bounds, sign));
-            occupied = System.Math.Max(occupied, partX);
-            occupiedY = System.Math.Max(occupiedY, partY);
             hasParts = true;
         }
         if (!hasParts)
@@ -164,76 +131,16 @@ public static class AutomaticCutOffPlanner
 
         // Use distances from the coordinate origin, not the sheet's lower-left corner.
         var length = plate.Size.Length;
-        var width = plate.Size.Width;
         occupied = System.Math.Min(occupied, length);
-        occupiedY = System.Math.Min(occupiedY, width);
+        var separator = occupied + System.Math.Max(plate.PartSpacing, settings.PartClearance)
-        var margin = System.Math.Max(plate.PartSpacing, settings.PartClearance) + GeometryTolerance;
+            + GeometryTolerance;
-        var nominalSeparator = 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>();
-
-        // A band beyond the parts along Y is kept by a full-length horizontal separator; the
-        // vertical lines then stop at it instead of slicing the band. A user's line clear of the
-        // parts is honored; a new one is proposed only when its band beats the X tail.
-        var horizontalDistance = plate.CutOffs
-            .Where(c => c?.Axis == CutOffAxis.Horizontal && Finite(c.Position) && FullLengthLimits(c, bounds, settings))
-            .Select(c => ySign * c.Position.Y)
-            .Where(distance => distance > occupiedY + GeometryTolerance && distance < width - GeometryTolerance
-                && width - distance >= options.MinimumTailLength)
-            .Select(distance => (double?)distance)
-            .Min();
-        var horizontalExists = horizontalDistance.HasValue;
-        if (!horizontalExists && options.KeepHorizontalRemnant)
-        {
-            var proposed = occupiedY + margin;
-            var tailArea = hasTailCandidate && length - separator >= options.MinimumTailLength
-                ? (length - separator) * width : 0;
-            if (double.IsFinite(proposed) && proposed < width - GeometryTolerance
-                && width - proposed >= options.MinimumTailLength && (width - proposed) * length > tailArea)
-                horizontalDistance = proposed;
-        }
-        if (horizontalDistance.HasValue && !horizontalExists)
-        {
-            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);
-            if (limited || clamp != null)
-            {
-                diagnostics.Add(new AutomaticCutOffDiagnostic(
-                    AutomaticCutOffDiagnosticCode.NoSafeHorizontalSeparator,
-                    (clamp != null ? $"A horizontal separator at Y = {y:G8} would cross clamp '{clamp.Id}'"
-                        : $"A same-line manual cut at Y = {y:G8} has different limits")
-                    + "; vertical lines cross the full sheet width instead."));
-                horizontalDistance = null;
-            }
-        }
-
         // A tail too short to keep stays attached to the skeleton, so the strip grid must
         // continue to the sheet end; stopping at the skipped separator would leave a final
-        // strip longer than the spacing. Beside a kept horizontal band the tail is a corner
+        // strip longer than the spacing.
-        // piece, which must also be wide enough to keep.
+        var keepsTail = hasTailCandidate && length - separator >= options.MinimumTailLength;
-        bool KeepsTail(double? band) => hasTailCandidate && length - separator >= options.MinimumTailLength
-            && (band == null || band.Value >= options.MinimumTailLength);
-        var keepsTail = KeepsTail(horizontalDistance);
         var usedSpan = keepsTail ? separator : length;
-        // Bound the count for either outcome: the horizontal separator is verified only below.
+        var candidateCount = System.Math.Ceiling(usedSpan / options.Spacing);
-        var candidateCount = System.Math.Ceiling(System.Math.Max(usedSpan, KeepsTail(null) ? separator : length)
-            / options.Spacing);
         Require(double.IsFinite(candidateCount) && candidateCount <= MaximumCandidateCount,
             $"Spacing would generate more than {MaximumCandidateCount} cut-off candidates.", nameof(options));
 
@@ -241,31 +148,7 @@ public static class AutomaticCutOffPlanner
         ValidateExisting(plate, bounds, settings);
         var cache = Plate.BuildPerimeterCache(plate);
         var definitions = new List<CutOff>();
-        CutOff horizontalSeparator = null;
+        var diagnostics = new List<AutomaticCutOffDiagnostic>();
-        if (horizontalDistance.HasValue && !horizontalExists)
-        {
-            horizontalSeparator = new CutOff(new Vector(0, ySign * horizontalDistance.Value), CutOffAxis.Horizontal);
-            horizontalSeparator.Regenerate(plate, settings, cache);
-            if (!HasUsableSegments(horizontalSeparator.Drawing.Program, false) ||
-                !IsFullSpanProgram(horizontalSeparator.Drawing.Program, false, bounds.Left, bounds.Right))
-            {
-                diagnostics.Add(new AutomaticCutOffDiagnostic(
-                    AutomaticCutOffDiagnosticCode.NoSafeHorizontalSeparator,
-                    "No full-length horizontal separator survives the current settings; "
-                    + "vertical lines cross the full sheet width instead."));
-                horizontalSeparator = null;
-                horizontalDistance = null;
-                keepsTail = KeepsTail(null);
-                usedSpan = keepsTail ? separator : length;
-                candidateCount = System.Math.Ceiling(usedSpan / options.Spacing);
-            }
-        }
-        // Vertical lines run from the origin-side edge up to a kept band's separator.
-        var horizontalY = horizontalDistance.HasValue ? ySign * horizontalDistance.Value : (double?)null;
-        var startLimit = ySign < 0 ? horizontalY : null;
-        var endLimit = ySign > 0 ? horizontalY : null;
-        var spanLow = startLimit ?? bounds.Bottom;
-        var spanHigh = endLimit ?? bounds.Top;
         var separated = false;
         var separatorX = (double?)null;
         var shifted = options.MinimumStripLength.HasValue && options.MinimumStripLength.Value < options.Spacing;
@@ -279,7 +162,7 @@ public static class AutomaticCutOffPlanner
             // Full-span definitions fix the strip boundaries, even when their emitted
             // programs are segmented. Partial cuts remain obstacles, not boundaries.
             var boundaries = plate.CutOffs
-                .Where(c => c.Axis == CutOffAxis.Vertical && Spans(c))
+                .Where(c => c.Axis == CutOffAxis.Vertical && FullSpanLimits(c, bounds, settings))
                 .Select(c => sign * c.Position.X)
                 .Where(distance => distance > GeometryTolerance && distance < usedSpan - GeometryTolerance)
                 .Distinct().OrderBy(distance => distance).Append(usedSpan);
@@ -321,14 +204,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,
@@ -336,15 +212,6 @@ public static class AutomaticCutOffPlanner
                 + "and strip lines continue to the sheet end. Existing cut-offs are unchanged. No retained tail is claimed.",
                 X: sign * separator));
 
-        if (horizontalSeparator != null)
-            definitions.Add(horizontalSeparator);
-        if (horizontalY.HasValue)
-            diagnostics.Add(new AutomaticCutOffDiagnostic(
-                AutomaticCutOffDiagnosticCode.HorizontalRemnant,
-                $"Vertical lines stop at the {(horizontalExists ? "existing" : "new")} horizontal separator at "
-                + $"Y = {horizontalY.Value:G8}, keeping a {width - horizontalDistance.Value:G8}-wide band "
-                + "along the sheet length."));
-
         if (diagnostics.Any(d => d.IsBlocking))
         {
             // A partial proposal must not accidentally be accepted around a manual conflict.
@@ -352,24 +219,12 @@ public static class AutomaticCutOffPlanner
             stripCutLength = 0;
             separated = false;
             separatorX = null;
-            horizontalY = null;
         }
         // The legacy placement loop stays untouched. Its detached programs are already
         // regenerated, so reporting their actual new strip cutting needs no new search.
         if (!shifted)
             fixedGridCutLength = stripCutLength;
 
-        // Lines are planned and measured without the head-locked overcut: it only extends the
-        // segment reaching the far edge past the sheet, where there is nothing to separate.
-        if (settings.NewCutOffHeadLockOvercut > 0)
-        {
-            foreach (var definition in definitions)
-            {
-                definition.HeadLockOvercut = settings.NewCutOffHeadLockOvercut;
-                definition.Regenerate(plate, settings, cache);
-            }
-        }
-
         return new AutomaticCutOffPlan
         {
             Definitions = definitions.AsReadOnly(),
@@ -381,22 +236,8 @@ public static class AutomaticCutOffPlanner
             TailSeparatorX = separatorX,
             StripCutLength = stripCutLength,
             FixedGridCutLength = fixedGridCutLength,
-            HorizontalSeparatorY = horizontalY,
-            HorizontalRemnantWidth = horizontalY.HasValue ? width - horizontalDistance.Value : 0,
         };
 
-        CutOff NewVertical(double x) => new(new Vector(x, 0), CutOffAxis.Vertical)
-        {
-            StartLimit = startLimit,
-            EndLimit = endLimit,
-        };
-
-        // 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 &&
-            Near(cut.StartLimit ?? bounds.Bottom, startLimit ?? bounds.Bottom) &&
-            Near(cut.EndLimit ?? (bounds.Top + settings.Overtravel), endLimit ?? (bounds.Top + settings.Overtravel));
-
         void AddShiftedGap(double start, double end, int count, double step)
         {
             var nominal = new List<double>(count);
@@ -449,7 +290,8 @@ public static class AutomaticCutOffPlanner
             RegisterCandidate(distance);
             if (!measurements.TryGetValue(distance, out var measured))
             {
-                measured = NewVertical(sign * distance).MeasureSegments(plate, settings, cache);
+                measured = new CutOff(new Vector(sign * distance, 0), CutOffAxis.Vertical)
+                    .MeasureSegments(plate, settings, cache);
                 measurements.Add(distance, measured);
             }
             return measured;
@@ -460,7 +302,7 @@ public static class AutomaticCutOffPlanner
             var matches = plate.CutOffs.Where(c => c.Axis == CutOffAxis.Vertical &&
                 Near(c.Position.X, x)).ToList();
 
-            if (matches.Any(c => !Spans(c)))
+            if (matches.Any(c => !FullSpanLimits(c, bounds, settings)))
             {
                 diagnostics.Add(new AutomaticCutOffDiagnostic(
                     AutomaticCutOffDiagnosticCode.LimitedCutOffConflict,
@@ -482,7 +324,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);
@@ -493,9 +335,9 @@ public static class AutomaticCutOffPlanner
             // drawing can be stale, and a tolerance-close line can intersect a part at the tail.
             var existing = matches.FirstOrDefault();
             var candidate = existing == null
-                ? NewVertical(x)
+                ? new CutOff(new Vector(x, 0), CutOffAxis.Vertical)
                 : 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);
@@ -511,7 +353,7 @@ public static class AutomaticCutOffPlanner
 
             if (isSeparator)
             {
-                if (!usable || !IsFullSpanProgram(program, true, spanLow, spanHigh))
+                if (!usable || !IsFullSpanProgram(program, bounds))
                 {
                     WarnNoSeparator(x);
                     return;
@@ -519,7 +361,7 @@ public static class AutomaticCutOffPlanner
                 separated = true;
                 separatorX = candidate.Position.X;
             }
-            else if (usable && !IsFullSpanProgram(program, true, spanLow, spanHigh))
+            else if (usable && !IsFullSpanProgram(program, bounds))
                 diagnostics.Add(new AutomaticCutOffDiagnostic(
                     AutomaticCutOffDiagnosticCode.SegmentedCut,
                     "Part clearance or segment filtering interrupts this line; review scrap separation before relying on it.",
@@ -544,7 +386,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,
@@ -566,22 +408,18 @@ 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,
-            "A head-locked overcut must be finite and positive.", nameof(settings));
         Require(Enum.IsDefined(settings.CutDirection), "Unknown cut direction.", nameof(settings));
         Require(plate.Parts != null && plate.CutOffs != null,
             "Plate parts and cut-off collections are required.", nameof(plate));
     }
 
-    private static (double X, double Y) ValidatePart(Part part, Box sheet, int sign, int ySign)
+    private static double ValidatePart(Part part, Box sheet, int sign)
     {
         Require(Finite(part.Location) && double.IsFinite(part.Rotation),
             "Part pose must be finite.", "plate");
@@ -594,32 +432,19 @@ public static class AutomaticCutOffPlanner
         Require(ValidBox(cached) && Near(box.Left, cached.Left) && Near(box.Right, cached.Right) &&
             Near(box.Bottom, cached.Bottom) && Near(box.Top, cached.Top),
             "Part geometry has stale bounds; update it before planning.", "plate");
-        var hasDisplayPerimeter = DisplayPerimeterTail.HasDisplayPerimeterMotion(part.Program);
+        Require(Inside(box, sheet), "Part geometry extends outside the physical sheet.", "plate");
-        Require(Inside(box, sheet, hasDisplayPerimeter ? DisplayPerimeterSheetAllowance : GeometryTolerance),
-            "Part geometry extends outside the physical sheet.", "plate");
 
         // Checking raw coordinates above prevents NaNs being hidden by min/max comparisons.
         // Checking converted entities catches overflowing incremental moves and curve bounds.
         var hasMaterial = false;
         var occupied = sign > 0 ? box.Right : -box.Left;
-        var occupiedY = ySign > 0 ? box.Top : -box.Bottom;
         var roundoff = CutOff.GetBoundsRoundoff(part);
-        var entities = ConvertProgram.ToGeometry(part.Program);
+        foreach (var entity in ConvertProgram.ToGeometry(part.Program))
-        var outline = entities.Where(e => e.Layer == SpecialLayers.DisplayPerimeter).ToList();
-        foreach (var entity in entities)
         {
             var entityBox = entity.BoundingBox;
             Require(ValidBox(entityBox), "Part contains invalid converted geometry.", "plate");
             if (!SpecialLayers.IsMaterial(entity.Layer))
-            {
-                // Travel and marks (a scribe is lasered) keep the ordinary tolerance. Only a rapid
-                // ending on the outline (its first corner, or an applied program's display tail)
-                // shares the outline's allowance.
-                Require(Inside(entityBox.Translate(part.Location), sheet)
-                        || hasDisplayPerimeter && IsRapidOntoOutline(entity, outline, part.Location, sheet),
-                    "Part geometry extends outside the physical sheet.", "plate");
                 continue;
-            }
             entityBox = entityBox.Translate(part.Location);
             // Permit only bounded floating-point roundoff, with the same conservative
             // padding in CutOff's broad phase and fallback. Geometry-scale protrusions
@@ -627,15 +452,12 @@ public static class AutomaticCutOffPlanner
             Require(entityBox.Left >= cached.Left - roundoff && entityBox.Right <= cached.Right + roundoff &&
                 entityBox.Bottom >= cached.Bottom - roundoff && entityBox.Top <= cached.Top + roundoff,
                 "Converted material extends outside cached part bounds; repair it before planning.", "plate");
-            Require(Inside(entityBox, sheet,
+            Require(Inside(entityBox, sheet), "Part geometry extends outside the physical sheet.", "plate");
-                    entity.Layer == SpecialLayers.DisplayPerimeter ? DisplayPerimeterSheetAllowance : GeometryTolerance),
-                "Part geometry extends outside the physical sheet.", "plate");
             occupied = System.Math.Max(occupied, sign > 0 ? entityBox.Right : -entityBox.Left);
-            occupiedY = System.Math.Max(occupiedY, ySign > 0 ? entityBox.Top : -entityBox.Bottom);
             hasMaterial |= entityBox.Length > 0 || entityBox.Width > 0;
         }
         Require(hasMaterial, "Real parts must contain material geometry.", "plate");
-        return (occupied, occupiedY);
+        return occupied;
     }
 
     private static void ValidateProgram(Program program, HashSet<Program> path)
@@ -676,13 +498,11 @@ 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);
 
-    private static bool HasUsableSegments(Program program, bool vertical = true)
+    private static bool HasUsableSegments(Program program)
     {
         if (program.Codes.Count == 0 || program.Codes.Count % 2 != 0)
             return false;
@@ -690,50 +510,30 @@ public static class AutomaticCutOffPlanner
         {
             if (program.Codes[i] is not RapidMove from || program.Codes[i + 1] is not LinearMove to ||
                 !Finite(from.EndPoint) || !Finite(to.EndPoint) ||
-                (vertical ? !Near(from.EndPoint.X, to.EndPoint.X) : !Near(from.EndPoint.Y, to.EndPoint.Y)) ||
+                !Near(from.EndPoint.X, to.EndPoint.X) ||
-                (vertical ? System.Math.Abs(from.EndPoint.Y - to.EndPoint.Y)
+                System.Math.Abs(from.EndPoint.Y - to.EndPoint.Y) <= GeometryTolerance)
-                    : System.Math.Abs(from.EndPoint.X - to.EndPoint.X)) <= GeometryTolerance)
                 return false;
         }
         return true;
     }
 
-    private static bool FullLengthLimits(CutOff cut, Box bounds, CutOffSettings settings) =>
+    private static bool IsFullSpanProgram(Program program, Box bounds)
-        cut.Gaps.Count == 0 &&
-        Near(cut.StartLimit ?? bounds.Left, bounds.Left) &&
-        Near(cut.EndLimit ?? (bounds.Right + settings.Overtravel), bounds.Right + settings.Overtravel);
-
-    private static bool IsFullSpanProgram(Program program, bool vertical, double low, double high)
     {
         // No gaps, bridges, or filtered middle segments can separate the tail.
         if (program.Codes.Count != 2 || program.Codes[0] is not RapidMove from ||
             program.Codes[1] is not LinearMove to)
             return false;
-        var start = vertical ? from.EndPoint.Y : from.EndPoint.X;
+        return System.Math.Min(from.EndPoint.Y, to.EndPoint.Y) <= bounds.Bottom + GeometryTolerance &&
-        var end = vertical ? to.EndPoint.Y : to.EndPoint.X;
+            System.Math.Max(from.EndPoint.Y, to.EndPoint.Y) >= bounds.Top - GeometryTolerance;
-        return System.Math.Min(start, end) <= low + GeometryTolerance &&
-            System.Math.Max(start, end) >= high - GeometryTolerance;
     }
 
     private static bool ValidBox(Box box) => box != null && Finite(box.Location) &&
         Nonnegative(box.Length) && Nonnegative(box.Width) &&
         double.IsFinite(box.Right) && double.IsFinite(box.Top);
 
-    // A rapid that leaves the sheet only at an end lying on the display perimeter, within its allowance.
+    private static bool Inside(Box box, Box sheet) =>
-    private static bool IsRapidOntoOutline(Entity entity, List<Entity> outline, Vector location, Box sheet)
+        box.Left >= sheet.Left - GeometryTolerance && box.Right <= sheet.Right + GeometryTolerance &&
-    {
+        box.Bottom >= sheet.Bottom - GeometryTolerance && box.Top <= sheet.Top + GeometryTolerance;
-        if (entity.Layer != SpecialLayers.Rapid || entity is not Line rapid
-            || !Inside(rapid.BoundingBox.Translate(location), sheet, DisplayPerimeterSheetAllowance))
-            return false;
-        bool Allowed(Vector point) =>
-            Inside(new Box(point.X + location.X, point.Y + location.Y, 0, 0), sheet)
-            || outline.Any(e => e.ClosestPointTo(point).DistanceTo(point) <= GeometryTolerance);
-        return Allowed(rapid.StartPoint) && Allowed(rapid.EndPoint);
-    }
-
-    private static bool Inside(Box box, Box sheet, double tolerance = GeometryTolerance) =>
-        box.Left >= sheet.Left - tolerance && box.Right <= sheet.Right + tolerance &&
-        box.Bottom >= sheet.Bottom - tolerance && box.Top <= sheet.Top + tolerance;
 
     private static bool Finite(Vector point) => double.IsFinite(point.X) && double.IsFinite(point.Y);
     private static bool Nonnegative(double value) => double.IsFinite(value) && value >= 0;

OpenNest.Core/BestFit/IBestFitStore.cs

@@ -21,17 +21,12 @@ namespace OpenNest.BestFit
         IReadOnlyList<double> HullAngles
     );
 
-    /// <summary>
+    /// <summary>The saved best-fit results for one drawing at one plate size and spacing.</summary>
-    /// The saved best-fit results for one drawing at one plate size and spacing.
-    /// <paramref name="CanonicalAngle"/> is the drawing's canonical angle (radians) when the
-    /// set was saved: the frame its pair geometry is in. Null means the frame is unknown.
-    /// </summary>
     public sealed record SavedPairSet(
         double PlateWidth,
         double PlateHeight,
         double Spacing,
-        IReadOnlyList<SavedPairResult> Results,
+        IReadOnlyList<SavedPairResult> Results
-        double? CanonicalAngle = null
     );
 
     /// <summary>
@@ -50,10 +45,7 @@ namespace OpenNest.BestFit
             IReadOnlySet<(double Width, double Length, double Spacing)> plateKeys
         );
 
-        /// <summary>
+        /// <summary>Restores saved sets for <paramref name="drawing"/>.</summary>
-        /// Restores saved sets for <paramref name="drawing"/>. Sets saved in a frame other
-        /// than the drawing's current canonical frame, or in an unknown one, are stale.
-        /// </summary>
         void Import(Drawing drawing, IReadOnlyList<SavedPairSet> sets);
     }
 }

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/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

@@ -238,7 +238,7 @@ namespace OpenNest.CNC
                 builder.PartIndex = i;
                 var mode = Mode.Absolute;
                 var pos = part.Location;
-                builder.AddProgram(DisplayPerimeterTail.WithoutTail(part.Program), part.Location, ref mode, ref pos);
+                builder.AddProgram(part.Program, part.Location, ref mode, ref pos);
             }
 
             var steps = ContourTiming.Finish(builder.Steps, plate, parameters);
@@ -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

@@ -36,45 +36,14 @@ internal enum AutomaticEntryKind
 
     /// <summary>A drawing pin's own entry: the one and only candidate of a pinned contour.</summary>
     Pinned = 7,
-
-    /// <summary>
-    /// The perimeter point where a tab best keeps the part level on its support bed; only a
-    /// perimeter tabbed for support has it (see <see cref="PreparedContours.WithSupportTab"/>).
-    /// </summary>
-    SupportTab = 8,
-
-    /// <summary>
-    /// A cutout entry pierced where eroding the cutout leaves room (see
-    /// <see cref="PreparedContours.ErodedPierceEntries"/>): only offered once no configured
-    /// lead-in of the cutout fits.
-    /// </summary>
-    ErodedPierce = 9,
-}
-
-/// <summary>
-/// Which automatic entries a perimeter tabbed for support offers (see
-/// <see cref="PreparedContours.WithSupportTab"/>); every other contour offers its whole catalog.
-/// </summary>
-internal enum SupportEntries
-{
-    /// <summary>Entries whose tab steadies the part, clear of inside corners, plus its best tab point.</summary>
-    Steadying,
-
-    /// <summary>Every entry clear of inside corners: the fallback when no steadying entry fits.</summary>
-    ClearOfInsideCorners,
-
-    /// <summary>Every entry: the last fallback, when nothing clear of inside corners fits.</summary>
-    Any,
 }
 
 /// <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

@@ -55,24 +55,23 @@ internal static class ContourProgramVerifier
             var first = run.Curves[0];
             var ringIndex = -1;
             var entityIndex = -1;
-            // The admitted slack is far below any extent margin, so only boundaries near the run's
+            for (var r = 0; r < material.Rings.Count && ringIndex < 0; r++)
-            // start can contain it; they come in ring order, as the full scan met them.
-            foreach (var (r, e) in material.PositionsNear(new(first.Start.X, first.Start.Y, first.Start.X, first.Start.Y)))
             {
-                Query(token, ref budget);
                 var admitted = AdmittedClosureSlack(material.Rings[r]);
-                var curve = material.Rings[r][e];
+                for (var e = 0; e < material.Rings[r].Length; e++)
-                if (curve.SameDirection(first, admitted) && curve.Contains(first.Start, admitted)
-                    && curve.DistanceAlong(first.Start) < curve.Length - Epsilon)
                 {
-                    ringIndex = r;
+                    Query(token, ref budget);
-                    entityIndex = e;
+                    var curve = material.Rings[r][e];
-                    break;
+                    if (curve.SameDirection(first, admitted) && curve.Contains(first.Start, admitted)
+                        && curve.DistanceAlong(first.Start) < curve.Length - Epsilon)
+                    {
+                        ringIndex = r;
+                        entityIndex = e;
+                        break;
+                    }
                 }
             }
             if (ringIndex < 0) return false;
-            // A display perimeter is never cut: any run along it is not this plan.
-            if (ringIndex == 0 && material.HasDisplayPerimeter) return false;
             var tabs = material.Tabs[ringIndex];
             if (tabs.Any(tab => tab))
             {
@@ -109,7 +108,7 @@ internal static class ContourProgramVerifier
             if (!Follows(run.Curves, ring, entityIndex, ring[entityIndex].DistanceAlong(first.Start),
                 true, tolerance, token, ref budget)) return false;
         }
-        return visited.Count == material.Rings.Count - (material.HasDisplayPerimeter ? 1 : 0);
+        return visited.Count == material.Rings.Count;
     }
 
     // Indexes of the curves that start a span between tabs: uncut-to-cut transitions.

OpenNest.Core/CNC/CuttingPlanning/CuttingPlanCommit.cs

@@ -22,39 +22,20 @@ internal sealed class PlannedPartProgram
     public CuttingParameters Parameters { get; }
 }
 
-/// <summary>
-/// An owned cutoff segment program cut the other way at the far sheet edge
-/// (<see cref="CutOff.ReverseAtFarEdge"/>); Apply installs it and records the direction on the
-/// segment's cutoff definition, so regeneration keeps it.
-/// </summary>
-internal sealed class PlannedCutOffProgram
-{
-    public PlannedCutOffProgram(Part segment, Program program)
-    {
-        Segment = segment;
-        Program = program;
-    }
-
-    public Part Segment { get; }
-    public Program Program { get; }
-}
-
 /// <summary>The verified order and planned programs for one plate, bound to its captured state.</summary>
 internal sealed class PlateCuttingPlan
 {
     public PlateCuttingPlan(PlateCuttingState expected, IEnumerable<Part> order,
-        IEnumerable<PlannedPartProgram> programs = null, IEnumerable<PlannedCutOffProgram> cutOffs = null)
+        IEnumerable<PlannedPartProgram> programs = null)
     {
         Expected = expected;
         Order = order == null ? null : Array.AsReadOnly(order.ToArray());
         Programs = Array.AsReadOnly((programs ?? []).ToArray());
-        CutOffs = Array.AsReadOnly((cutOffs ?? []).ToArray());
     }
 
     public PlateCuttingState Expected { get; }
     public IReadOnlyList<Part> Order { get; }
     public IReadOnlyList<PlannedPartProgram> Programs { get; }
-    public IReadOnlyList<PlannedCutOffProgram> CutOffs { get; }
 }
 
 public enum CuttingCommitStatus
@@ -62,7 +43,7 @@ public enum CuttingCommitStatus
     Applied,
     Stale,
     InvalidInput,
-    Canceled,
+    Cancelled,
     Failed
 }
 
@@ -107,7 +88,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.");
@@ -126,7 +107,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);
@@ -180,49 +161,27 @@ internal static class CuttingPlanCommit
                 }
                 programs.Add((planned.Part, planned.Program, bounds, planned.Parameters));
             }
-            var cutOffs = new List<(Part, Program, CutOff)>();
-            foreach (var planned in plan.CutOffs)
-            {
-                if (planned?.Segment == null || !onPlate.Contains(planned.Segment) || !targets.Add(planned.Segment))
-                    return Invalid(plate, "Planned programs must target distinct parts of their own plate.");
-                var definition = plate.CutOffs.FirstOrDefault(c => ReferenceEquals(c?.Drawing, planned.Segment.BaseDrawing));
-                // Only the placed far-edge segment, cut exactly the other way, may be installed.
-                if (definition == null || planned.Program == null || live.Contains(planned.Program)
-                    || !installed.Add(planned.Program)
-                    || CutOff.ReverseAtFarEdge(planned.Segment.Program) is not { } expected
-                    || !ProgramContent.Equal(expected, planned.Program, token))
-                    return Invalid(plate, "A cutoff segment can only be installed cut the other way at the far edge.");
-                cutOffs.Add((planned.Segment, planned.Program, definition));
-            }
             var reordered = !order.SequenceEqual(plate.Parts, ReferenceEqualityComparer.Instance);
-            staged.Add(new(plate, order, programs, cutOffs, reordered || programs.Count != 0 || cutOffs.Count != 0));
+            staged.Add(new(plate, order, programs, reordered || programs.Count != 0));
         }
 
         // 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,
+        var undo = new List<(Plate Plate, Part[] Order, (Part Part, PartCuttingState State)[] States)>();
-            (CutOff CutOff, bool FarEdgeFirst, Program Program)[] CutOffs)>();
         try
         {
             foreach (var item in staged)
             {
                 undo.Add((item.Plate, item.Plate.Parts.ToArray(),
-                    item.Programs.Select(p => p.Part).Concat(item.CutOffs.Select(c => c.Segment))
+                    item.Programs.Select(p => (p.Part, p.Part.CaptureCuttingState())).ToArray()));
-                        .Select(part => (part, part.CaptureCuttingState())).ToArray(),
-                    item.CutOffs.Select(c => (c.CutOff, c.CutOff.FarEdgeFirst, c.CutOff.Drawing.Program)).ToArray()));
                 item.Plate.Parts.SetOrder(item.Order);
                 foreach (var (part, program, bounds, parameters) in item.Programs)
                 {
                     beforeInstall?.Invoke(item.Plate, part);
                     part.InstallPlannedProgram(program, bounds, parameters);
                 }
-                foreach (var (segment, program, cutOff) in item.CutOffs)
-                {
-                    beforeInstall?.Invoke(item.Plate, segment);
-                    cutOff.InstallFarEdgeSegment(segment, program);
-                }
             }
         }
         catch (Exception ex)
@@ -231,11 +190,6 @@ internal static class CuttingPlanCommit
             {
                 foreach (var (part, state) in undo[i].States)
                     part.RestoreCuttingState(state);
-                foreach (var (cutOff, farEdgeFirst, program) in undo[i].CutOffs)
-                {
-                    cutOff.FarEdgeFirst = farEdgeFirst;
-                    cutOff.Drawing.Program = program;
-                }
                 undo[i].Plate.Parts.SetOrder(undo[i].Order);
             }
             return new(CuttingCommitStatus.Failed, "Install failed; every plate was restored.",
@@ -254,6 +208,5 @@ internal static class CuttingPlanCommit
         new(CuttingCommitStatus.InvalidInput, message, plate);
 
     private sealed record Staged(Plate Plate, Part[] Order,
-        List<(Part Part, Program Program, Box Bounds, CuttingParameters Parameters)> Programs,
+        List<(Part Part, Program Program, Box Bounds, CuttingParameters Parameters)> Programs, bool Changed);
-        List<(Part Segment, Program Program, CutOff CutOff)> CutOffs, bool Changed);
 }

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,24 +41,13 @@ 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.");
                 if (code == null)
                     throw new ArgumentException("Program contains a missing instruction.");
-                // A display perimeter's tail is never executed: an applied program ends at its marker.
-                // Only a well-formed tail at the end of the part's own program may end the read.
-                if (code is Comment { Value: DisplayPerimeterTail.Marker })
-                {
-                    if (!ReferenceEquals(current, program))
-                        throw new ArgumentException("A display perimeter tail can only end the part's own program, not a sub-program.");
-                    DisplayPerimeterTail.IndexOf(current);
-                    break;
-                }
                 if (requireSupportedTypes)
                 {
                     var type = code.GetType();
@@ -74,8 +61,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 +82,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 +97,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/IncrementalClosureDrift.cs

@@ -49,8 +49,8 @@ internal static class IncrementalClosureDrift
 
     // The chains material capture closes: cut, display and tab moves between rapids and other layers.
     private static bool IsContour(Motion motion) => !motion.Suppressed
-        && motion is LinearMove { Layer: LayerType.Cut or LayerType.Display or LayerType.Tab or LayerType.DisplayPerimeter }
+        && motion is LinearMove { Layer: LayerType.Cut or LayerType.Display or LayerType.Tab }
-            or ArcMove { Layer: LayerType.Cut or LayerType.Display or LayerType.Tab or LayerType.DisplayPerimeter };
+            or ArcMove { Layer: LayerType.Cut or LayerType.Display or LayerType.Tab };
 
     private static bool TryClose(Program program, List<Motion> run, Vector start, Vector end, int next)
     {
@@ -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

@@ -12,9 +12,8 @@ namespace OpenNest.CNC.CuttingPlanning;
 public sealed class LeadMaterialSnapshot
 {
     private LeadMaterialSnapshot(IReadOnlyList<PostVerificationGeometry.Curve[]> rings, IReadOnlyList<bool[]> tabs,
-        string reason, bool displayPerimeter = false)
+        string reason)
     {
-        HasDisplayPerimeter = displayPerimeter;
         Rings = rings;
         Tabs = tabs;
         Reason = reason;
@@ -42,21 +41,10 @@ public sealed class LeadMaterialSnapshot
     /// </summary>
     internal IReadOnlyList<bool[]> Tabs { get; }
 
-    /// <summary>
-    /// True when the perimeter (<see cref="Rings"/>[0]) is a display perimeter: a supplied blank's
-    /// edge that bounds material but is never cut. Every other ring is a hole the program cuts.
-    /// </summary>
-    internal bool HasDisplayPerimeter { get; }
-
     /// <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
         {
@@ -65,8 +53,6 @@ public sealed class LeadMaterialSnapshot
             var ringTabs = new List<bool[]>();
             var chain = new List<PostVerificationGeometry.Curve>();
             var chainTabs = new List<bool>();
-            var ringDisplay = new List<bool>();
-            var chainDisplay = new List<bool>();
             foreach (var motion in execution.Motions)
             {
                 token.ThrowIfCancellationRequested();
@@ -77,8 +63,7 @@ public sealed class LeadMaterialSnapshot
                     continue;
                 }
                 // A tabbed cutout's tabs are never cut but still close its hole.
-                // A display perimeter is never cut but still bounds the blank's material.
+                if (motion.Layer is not (LayerType.Cut or LayerType.Display or LayerType.Tab))
-                if (motion.Layer is not (LayerType.Cut or LayerType.Display or LayerType.Tab or LayerType.DisplayPerimeter))
                     throw new ArgumentException("Material capture contains an unsupported layer.");
                 var curve = motion.Curve;
                 if (curve == null || !double.IsFinite(curve.Length) || curve.Length <= PostVerificationGeometry.Epsilon)
@@ -87,7 +72,6 @@ public sealed class LeadMaterialSnapshot
                     throw new ArgumentException("Material contour is discontinuous.");
                 chain.Add(curve);
                 chainTabs.Add(motion.Layer == LayerType.Tab);
-                chainDisplay.Add(motion.Layer == LayerType.DisplayPerimeter);
                 if (NominalContourClosure.IsClosed(chain[0].Start, chain[^1].End))
                     Finish();
             }
@@ -96,46 +80,42 @@ public sealed class LeadMaterialSnapshot
                 throw new ArgumentException("Material has no closed contour.");
             var budget = 1000000;
             // Certify simple rings and mutually disjoint boundaries before containment.
-            foreach (var (r, i, s, j) in ContactCandidates(rings, token))
+            for (var r = 0; r < rings.Count; r++)
-            {
+                for (var s = r; s < rings.Count; s++)
-                token.ThrowIfCancellationRequested();
+                    for (var i = 0; i < rings[r].Length; i++)
-                if (--budget < 0)
+                        for (var j = s == r ? i + 1 : 0; j < rings[s].Length; j++)
-                    throw new NotSupportedException("Material validation exceeds the native query limit.");
+                        {
-                var a = rings[r][i];
+                            token.ThrowIfCancellationRequested();
-                var b = rings[s][j];
+                            if (--budget < 0)
-                var contacts = a.Contacts(b, out var overlap);
+                                throw new NotSupportedException("Material validation exceeds the native query limit.");
-                var adjacent = r == s && (j == i + 1 || (i == 0 && j == rings[r].Length - 1));
+                            var a = rings[r][i];
-                var arcJoint = adjacent && a.IsFiniteArc && b.IsFiniteArc
+                            var b = rings[s][j];
-                    && (a.End.DistanceTo(b.Start) <= Tolerance.Epsilon
+                            var contacts = a.Contacts(b, out var overlap);
-                        || a.Start.DistanceTo(b.End) <= Tolerance.Epsilon);
+                            var adjacent = r == s && (j == i + 1 || (i == 0 && j == rings[r].Length - 1));
-                // Native arc queries pad angles by 1e-5 radians, admitting
+                            var arcJoint = adjacent && a.IsFiniteArc && b.IsFiniteArc
-                // intersections on an extension (distance grows with radius).
+                                && (a.End.DistanceTo(b.Start) <= Tolerance.Epsilon
-                // At a shared arc joint require both actual finite spans;
+                                    || a.Start.DistanceTo(b.End) <= Tolerance.Epsilon);
-                // overlap and genuine second intersections still refuse.
+                            // Native arc queries pad angles by 1e-5 radians, admitting
-                if (arcJoint)
+                            // intersections on an extension (distance grows with radius).
-                    contacts = contacts.Where(p => !a.IsOutsideArcSpan(p) && !b.IsOutsideArcSpan(p)).ToArray();
+                            // At a shared arc joint require both actual finite spans;
-                // Native contacts at rounded arc/line joints can drift from the
+                            // overlap and genuine second intersections still refuse.
-                // authored endpoint. Use the shared geometry tolerance only to
+                            if (arcJoint)
-                // recognize that joint; overlaps and other contacts still refuse.
+                                contacts = contacts.Where(p => !a.IsOutsideArcSpan(p) && !b.IsOutsideArcSpan(p)).ToArray();
-                if (overlap || contacts.Any(p => !adjacent
+                            // Native contacts at rounded arc/line joints can drift from the
-                    || !(p.DistanceTo(a.End) <= Tolerance.Epsilon
+                            // authored endpoint. Use the shared geometry tolerance only to
-                        && p.DistanceTo(b.Start) <= Tolerance.Epsilon)
+                            // recognize that joint; overlaps and other contacts still refuse.
-                    && !(p.DistanceTo(a.Start) <= Tolerance.Epsilon
+                            if (overlap || contacts.Any(p => !adjacent
-                        && p.DistanceTo(b.End) <= Tolerance.Epsilon)))
+                                || !(p.DistanceTo(a.End) <= Tolerance.Epsilon
-                    throw new ArgumentException(r != s && (ringDisplay[r] || ringDisplay[s])
+                                    && p.DistanceTo(b.Start) <= Tolerance.Epsilon)
-                        ? "A display perimeter must enclose every other contour."
+                                && !(p.DistanceTo(a.Start) <= Tolerance.Epsilon
-                        : $"Material boundaries overlap, touch or self-intersect ({r}:{i}, {s}:{j}, overlap={overlap}).");
+                                    && p.DistanceTo(b.End) <= Tolerance.Epsilon)))
-            }
+                                throw new ArgumentException($"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.");
@@ -143,23 +123,16 @@ public sealed class LeadMaterialSnapshot
                 }
             }
             if (outer < 0)
-                throw new ArgumentException(ringDisplay.Contains(true)
+                throw new ArgumentException("Material must have exactly one enclosing perimeter.");
-                    ? "A display perimeter must enclose every other contour."
+            if (ringTabs[outer].Any(tab => tab))
-                    : "Material must have exactly one enclosing perimeter.");
-            if (!sharedSpans && ringTabs[outer].Any(tab => tab))
                 throw new ArgumentException("A perimeter cannot have tabs.");
-            if (ringDisplay.Where((_, i) => i != outer).Any(display => display))
+            var holes = rings.Where((_, i) => i != outer).ToArray();
-                throw new ArgumentException("A display perimeter must enclose every other contour.");
+            for (var i = 0; i < holes.Length; i++)
-            if (ringDisplay[outer] && rings.Count == 1)
+                for (var j = i + 1; j < holes.Length; j++)
-                throw new ArgumentException("A display perimeter with no cutouts has nothing to cut.");
+                    if (Inside(holes[i][0].Start, holes[j], token) || Inside(holes[j][0].Start, holes[i], token))
-            var holeRings = Enumerable.Range(0, rings.Count).Where(i => i != outer).ToArray();
-            var holes = holeRings.Select(i => rings[i]).ToArray();
-            for (var i = 0; i < holeRings.Length; i++)
-                for (var j = i + 1; j < holeRings.Length; j++)
-                    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]);
+                new[] { ringTabs[outer] }.Concat(ringTabs.Where((_, i) => i != outer)).ToArray(), null);
 
             void Finish()
             {
@@ -172,14 +145,10 @@ public sealed class LeadMaterialSnapshot
                         $"Nominal material contour {rings.Count + 1} is open: endpoint gap {gap:G6} model units exceeds closure tolerance {NominalContourClosure.Tolerance:G6}.")
                         + " Review the source contour in the drawing editor; gaps cannot be filled implicitly.");
                 }
-                if (chainDisplay.Contains(true) && chainDisplay.Contains(false))
-                    throw new ArgumentException("A display perimeter must be one whole closed contour.");
                 rings.Add(chain.ToArray());
                 ringTabs.Add(chainTabs.ToArray());
-                ringDisplay.Add(chainDisplay.Count > 0 && chainDisplay[0]);
                 chain.Clear();
                 chainTabs.Clear();
-                chainDisplay.Clear();
             }
         }
         catch (Exception ex) when (ex is ArgumentException or NotSupportedException)
@@ -188,182 +157,18 @@ public sealed class LeadMaterialSnapshot
         }
     }
 
-    /// <summary>
+    internal bool ContainsMaterial(Vector point, CancellationToken token) => Inside(point, Rings[0], token)
-    /// The boundary pairs certification queries natively, in the order of the full pairwise scan
+        && !Rings.Skip(1).Any(hole => Inside(point, hole, token));
-    /// (ring, other ring, curve, other curve). A pair whose extents are clear by the lead checks'
+
-    /// margin (<see cref="PostVerificationGeometry.Extent.IsClearOfQueriesFrom"/>) can report no
+    internal static bool Inside(Vector point, IReadOnlyList<PostVerificationGeometry.Curve> ring, CancellationToken token)
-    /// native contact, so it is left out; a sweep over X finds the rest without visiting every pair.
-    /// Material that is not well conditioned keeps every pair.
-    /// </summary>
-    private static List<(int R, int I, int S, int J)> ContactCandidates(
-        IReadOnlyList<PostVerificationGeometry.Curve[]> rings, CancellationToken token)
     {
-        var curves = new List<(int Ring, int Index, PostVerificationGeometry.Extent Extent)>();
+        var inside = false;
-        var whole = PostVerificationGeometry.Extent.None;
+        foreach (var curve in ring)
-        for (var r = 0; r < rings.Count; r++)
-            for (var i = 0; i < rings[r].Length; i++)
-            {
-                curves.Add((r, i, rings[r][i].Extent));
-                whole = whole.Union(rings[r][i].Extent);
-            }
-        var pairs = new List<(int R, int I, int S, int J)>();
-        if (!whole.IsWellConditioned)
         {
-            for (var a = 0; a < curves.Count; a++)
+            token.ThrowIfCancellationRequested();
-                for (var b = a + 1; b < curves.Count; b++)
+            if (curve.CrossesRay(point))
-                    pairs.Add((curves[a].Ring, curves[a].Index, curves[b].Ring, curves[b].Index));
+                inside = !inside;
         }
-        else
+        return inside;
-        {
-            // No pair spans more than the whole material, so this bounds every pair's margin.
-            var reach = PostVerificationGeometry.Extent.ClearMargin + PostVerificationGeometry.Extent.SpanRounding
-                * System.Math.Max(whole.MaxX - whole.MinX, whole.MaxY - whole.MinY);
-            var byMinX = curves.OrderBy(c => c.Extent.MinX).ToArray();
-            for (var a = 0; a < byMinX.Length; a++)
-            {
-                token.ThrowIfCancellationRequested();
-                var first = byMinX[a];
-                for (var b = a + 1; b < byMinX.Length && byMinX[b].Extent.MinX <= first.Extent.MaxX + reach; b++)
-                {
-                    var second = byMinX[b];
-                    if (first.Extent.IsClearOfQueriesFrom(second.Extent))
-                        continue;
-                    pairs.Add((first.Ring, first.Index).CompareTo((second.Ring, second.Index)) < 0
-                        ? (first.Ring, first.Index, second.Ring, second.Index)
-                        : (second.Ring, second.Index, first.Ring, first.Index));
-                }
-            }
-        }
-        pairs.Sort((x, y) => (x.R, x.S, x.I, x.J).CompareTo((y.R, y.S, y.I, y.J)));
-        return pairs;
     }
-
-    /// <summary>Material with fewer boundaries is scanned whole, exactly as before the index.</summary>
-    private const int IndexedBoundaries = 64;
-
-    private BoundaryIndex index;
-
-    /// <summary>
-    /// The boundaries a native query from <paramref name="query"/> can report a contact with, in
-    /// ring order: every boundary but those whose extents are clear of it by the lead checks'
-    /// margin plus <paramref name="reach"/> (<see cref="PostVerificationGeometry.Extent.IsClearOfQueriesFrom"/>).
-    /// Small material returns every boundary.
-    /// </summary>
-    internal IEnumerable<PostVerificationGeometry.Curve> BoundariesNear(PostVerificationGeometry.Extent query,
-        double reach = 0) => PositionsNear(query, reach).Select(p => Rings[p.Ring][p.Index]);
-
-    /// <summary>As <see cref="BoundariesNear"/>, each boundary as its ring and its index in that ring.</summary>
-    internal IEnumerable<(int Ring, int Index)> PositionsNear(PostVerificationGeometry.Extent query, double reach = 0)
-    {
-        if (BoundaryCount < IndexedBoundaries)
-            return Rings.SelectMany((ring, r) => ring.Select((_, i) => (r, i)));
-        return LazyInitializer.EnsureInitialized(ref index, () => new BoundaryIndex(Rings, Extent)).Near(query, reach);
-    }
-
-    internal bool ContainsMaterial(Vector point, CancellationToken token)
-    {
-        if (BoundaryCount < IndexedBoundaries)
-            return Inside(point, Rings[0], token) && !Rings.Skip(1).Any(hole => Inside(point, hole, token));
-        var holes = LazyInitializer.EnsureInitialized(ref index, () => new BoundaryIndex(Rings, Extent)).HolesOnRow(point.Y);
-        return Inside(point, Rings[0], token) && !holes.Any(hole => Inside(point, Rings[hole], token));
-    }
-
-    /// <summary>
-    /// A uniform grid of boundary extents over the material, for material with many holes. Read
-    /// only once built, so concurrent searches may share it.
-    /// </summary>
-    private sealed class BoundaryIndex
-    {
-        private readonly (int Ring, int Index)[] positions;
-        private readonly PostVerificationGeometry.Extent[] extents;
-        private readonly List<int>[] cells;
-        private readonly List<int>[] bands;
-        private readonly PostVerificationGeometry.Extent[] ringExtents;
-        private readonly int ringCount;
-        private readonly PostVerificationGeometry.Extent whole;
-        private readonly int columns;
-        private readonly int rows;
-        private readonly double width;
-        private readonly double height;
-
-        internal BoundaryIndex(IReadOnlyList<PostVerificationGeometry.Curve[]> rings, PostVerificationGeometry.Extent whole)
-        {
-            positions = rings.SelectMany((ring, r) => ring.Select((_, i) => (r, i))).ToArray();
-            extents = rings.SelectMany(r => r).Select(b => b.Extent).ToArray();
-            ringCount = rings.Count;
-            ringExtents = new PostVerificationGeometry.Extent[rings.Count];
-            this.whole = whole;
-            var side = System.Math.Max(1, (int)System.Math.Ceiling(System.Math.Sqrt(positions.Length)));
-            columns = side;
-            rows = side;
-            width = System.Math.Max(whole.MaxX - whole.MinX, double.Epsilon) / columns;
-            height = System.Math.Max(whole.MaxY - whole.MinY, double.Epsilon) / rows;
-            cells = new List<int>[columns * rows];
-            bands = new List<int>[rows];
-            if (!whole.IsWellConditioned)
-                return;
-            for (var ring = 1; ring < rings.Count; ring++)
-            {
-                var extent = rings[ring].Aggregate(PostVerificationGeometry.Extent.None, (e, curve) => e.Union(curve.Extent));
-                ringExtents[ring] = extent;
-                for (var band = Row(extent.MinY - PostVerificationGeometry.Extent.ClearMargin);
-                    band <= Row(extent.MaxY + PostVerificationGeometry.Extent.ClearMargin); band++)
-                    (bands[band] ??= new List<int>()).Add(ring);
-            }
-            for (var b = 0; b < positions.Length; b++)
-            {
-                var (x0, y0, x1, y1) = Cells(extents[b], 0);
-                for (var y = y0; y <= y1; y++)
-                    for (var x = x0; x <= x1; x++)
-                        (cells[y * columns + x] ??= new List<int>()).Add(b);
-            }
-        }
-
-        /// <summary>
-        /// The holes, in ring order, whose curves a ray along row <paramref name="y"/> can cross:
-        /// every hole but those whose extents are clear of the row (see
-        /// <see cref="PostVerificationGeometry.Extent.IsClearOfRow"/>).
-        /// </summary>
-        internal IEnumerable<int> HolesOnRow(double y)
-        {
-            if (!whole.IsWellConditioned || !(System.Math.Abs(y) <= PostVerificationGeometry.Extent.WellConditionedLimit))
-                return Enumerable.Range(1, ringCount - 1);
-            return (bands[Row(y)] ?? []).Where(ring => !ringExtents[ring].IsClearOfRow(y));
-        }
-
-        internal IEnumerable<(int Ring, int Index)> Near(PostVerificationGeometry.Extent query, double reach)
-        {
-            // The margin covers every pair's span, and each skip is then decided for the pair alone.
-            // Material or a query that is not well conditioned (whose cells were never built, for
-            // the material) keeps every boundary.
-            var union = whole.Union(query);
-            var margin = PostVerificationGeometry.Extent.ClearMargin + reach
-                + PostVerificationGeometry.Extent.SpanRounding * System.Math.Max(union.MaxX - union.MinX, union.MaxY - union.MinY);
-            if (!union.IsWellConditioned || !double.IsFinite(margin))
-                return positions;
-            var (x0, y0, x1, y1) = Cells(query, margin);
-            var found = new List<int>();
-            for (var y = y0; y <= y1; y++)
-                for (var x = x0; x <= x1; x++)
-                    if (cells[y * columns + x] is { } cell)
-                        found.AddRange(cell);
-            found.Sort();
-            var near = new List<(int Ring, int Index)>();
-            for (var i = 0; i < found.Count; i++)
-                if ((i == 0 || found[i] != found[i - 1]) && !query.IsClearOfQueriesFrom(extents[found[i]], reach))
-                    near.Add(positions[found[i]]);
-            return near;
-        }
-
-        // The cells an extent widened by margin covers, clamped to the grid.
-        private (int X0, int Y0, int X1, int Y1) Cells(PostVerificationGeometry.Extent extent, double margin) => (
-            Column(extent.MinX - margin), Row(extent.MinY - margin), Column(extent.MaxX + margin), Row(extent.MaxY + margin));
-
-        private int Column(double x) => (int)System.Math.Clamp(System.Math.Floor((x - whole.MinX) / width), 0, columns - 1);
-
-        private int Row(double y) => (int)System.Math.Clamp(System.Math.Floor((y - whole.MinY) / height), 0, rows - 1);
-    }
-
-    internal static bool Inside(Vector point, IReadOnlyList<PostVerificationGeometry.Curve> ring, CancellationToken token) =>
-        PostVerificationGeometry.Inside(point, ring, token);
 }

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,28 +119,13 @@ 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)
                     {
                         var edge = execution.Motions[groupEdge];
                         var joint = move.Layer == LayerType.Leadin ? edge.End : edge.Curve.Start;
                         var contourJoint = move.Layer == LayerType.Leadin ? adjacent.Curve.Start : adjacent.End;
-                        // A boundary clear of the contour's first motion contains none of its points.
+                        foreach (var boundary in target.Rings.SelectMany(r => r))
-                        foreach (var boundary in target.BoundariesNear(adjacent.Curve.Extent))
                         {
                             token.ThrowIfCancellationRequested();
                             if (--budget < 0)
@@ -201,13 +153,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++)
                 {
@@ -240,7 +190,10 @@ public static class LeadPathValidator
                         // Every boundary of material this far away is farther than the zone.
                         if (new PostVerificationGeometry.Extent(start.X, start.Y, start.X, start.Y)
                             .IsClearOfQueriesFrom(material.Extent, pierceRadius))
+                        {
+                            Charge(material.BoundaryCount);
                             continue;
+                        }
                         if (Clearance(material) is { } distance)
                             return (Short(distance, "another placed part"), other);
                     }
@@ -279,11 +232,11 @@ public static class LeadPathValidator
                 }
 
                 // Material too far from the lead for any native boundary query to report a contact
-                // (see IsClearOfQueriesFrom): the result the full scan gives. Only queries that run
+                // (see IsClearOfQueriesFrom): the result the full scan gives, charged as if it ran.
-                // are charged, so many far parts or holes do not exhaust the budget. Ray parity is
+                // Ray parity is still asked natively unless the lead lies beside the material's rows.
-                // still asked natively unless the lead lies beside the material's rows.
                 bool FarInside(LeadMaterialSnapshot material)
                 {
+                    Charge(material.BoundaryCount);
                     var midpoint = move.Curve.Midpoint;
                     return !material.Extent.IsClearOfRow(midpoint.Y) && material.ContainsMaterial(midpoint, token);
                 }
@@ -336,32 +289,19 @@ public static class LeadPathValidator
     internal static string MaterialContact(PostVerificationGeometry.Curve curve, LeadMaterialSnapshot material,
         Vector? permittedJoint, ref int budget, CancellationToken token, bool allowInterior = false)
     {
-        // Boundaries no native query from the curve can reach report no contact; only the others run.
+        foreach (var boundary in material.Rings.SelectMany(r => r))
-        foreach (var boundary in material.BoundariesNear(curve.Extent))
         {
             token.ThrowIfCancellationRequested();
             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;
 
@@ -53,6 +54,19 @@ internal static class NestedPartContainment
     /// <summary>Material extent of a clean program at a location: rapids and scribe marks excluded.</summary>
     internal static Box CleanBounds(Program clean, Vector location, CancellationToken token) =>
         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)
+            .Where(m => !m.Rapid && m.Layer is LayerType.Cut or LayerType.Display && 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

@@ -33,19 +33,18 @@ internal static class OwnedCuttingParameters
             PierceDiameter = Dimension(source.PierceDiameter),
             ExternalLeadIn = CopyLeadIn(source.ExternalLeadIn),
             InternalLeadIn = CopyLeadIn(source.InternalLeadIn),
+            ArcCircleLeadIn = CopyLeadIn(source.ArcCircleLeadIn),
             ExternalLeadOut = CopyLeadOut(source.ExternalLeadOut),
             InternalLeadOut = CopyLeadOut(source.InternalLeadOut),
+            ArcCircleLeadOut = CopyLeadOut(source.ArcCircleLeadOut),
             RoundLeadInAngles = source.RoundLeadInAngles,
             LeadInAngleIncrement = source.LeadInAngleIncrement,
+            AutoTabMinSize = Dimension(source.AutoTabMinSize),
+            AutoTabMaxSize = Dimension(source.AutoTabMaxSize),
             TabConfig = source.TabConfig == null
                 ? source.TabsEnabled ? throw new ArgumentException("Enabled tabs require a configuration.") : null
                 : CopyTab(source.TabConfig),
             TabsEnabled = source.TabsEnabled,
-            SupportTabs = source.SupportTabs,
-            TabBySize = source.TabBySize,
-            TabSizeMinWidth = Dimension(source.TabSizeMinWidth),
-            TabSizeMaxWidth = Dimension(source.TabSizeMaxWidth),
-            TabHeldMaxLength = Dimension(source.TabHeldMaxLength),
             Sequencing = new SequenceParameters
             {
                 Method = sequence.Method,
@@ -72,8 +71,7 @@ internal static class OwnedCuttingParameters
         NoLeadIn n when n.GetType() == typeof(NoLeadIn) => new NoLeadIn(),
         LineLeadIn n when n.GetType() == typeof(LineLeadIn) => new LineLeadIn
         { Length = Dimension(n.Length), ApproachAngle = Angle(n.ApproachAngle) },
-        ArcLeadIn n when n.GetType() == typeof(ArcLeadIn) => new ArcLeadIn
+        ArcLeadIn n when n.GetType() == typeof(ArcLeadIn) => new ArcLeadIn { Radius = Dimension(n.Radius) },
-        { Radius = Dimension(n.Radius), SweepAngle = Sweep(n.SweepAngle) },
         LineArcLeadIn n when n.GetType() == typeof(LineArcLeadIn) => new LineArcLeadIn
         { LineLength = Dimension(n.LineLength), ArcRadius = Dimension(n.ArcRadius), ApproachAngle = Angle(n.ApproachAngle) },
         LineLineLeadIn n when n.GetType() == typeof(LineLineLeadIn) => new LineLineLeadIn
@@ -139,7 +137,4 @@ internal static class OwnedCuttingParameters
     // Approach angles are degrees, not lengths. Signed and periodic angles are valid.
     private static double Angle(double value) => double.IsFinite(value)
         ? value : throw new ArgumentException("Angles must be finite.");
-
-    private static double Sweep(double value) => double.IsFinite(value) && value > 0 && value <= 180
-        ? value : throw new ArgumentException("Arc sweep must be in (0, 180] degrees.");
 }

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

@@ -27,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;
@@ -89,8 +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)).ToArray();
-                c.HeadLockOvercut, c.FarEdgeFirst)).ToArray();
         return new(plate, records.ToArray(), cutOffs, drawings, settings);
 
         void Fingerprint(CuttingParameters parameters)
@@ -163,24 +155,9 @@ public sealed class PlateCuttingState
             if (!ReferenceEquals(cutOff, record.CutOff) || !ReferenceEquals(cutOff.Drawing, record.Drawing)
                 || 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)
+                || !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;
@@ -226,9 +203,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);
-        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.Support;
 
 namespace OpenNest.CNC.CuttingPlanning;
 
@@ -15,25 +14,13 @@ public sealed record ContourChoice(int ContourOrdinal, int EntityOrdinal, Vector
     internal PreparedContours Owner { get; init; }
 
     /// <summary>
-    /// A pierce the planner placed off the contour: a perimeter's in open scrap for the pierce
+    /// A perimeter pierce the planner placed in open scrap for the pierce zone (see
-    /// zone (see <see cref="PreparedContours.ScrapPierceEntry"/>), or a cutout's where eroding it
+    /// <see cref="PreparedContours.ScrapPierceEntry"/>): the lead-in runs straight from here to
-    /// leaves room (see <see cref="PreparedContours.ErodedPierceEntries"/>). The lead-in runs
+    /// <see cref="Point"/> instead of the configured lead-in. Null for every other choice.
-    /// straight from here to <see cref="Point"/> instead of the configured lead-in; a cutout so
-    /// pierced has no lead-out. Null for every other choice.
     /// </summary>
     public Vector? Pierce { get; internal init; }
 }
 
-/// <summary>
-/// The shared cuts a common-line member makes before its remainder (see
-/// docs/common-line-cutting.md): open centerline cuts in part coordinates, each from
-/// <see cref="CommonLineCutPath.Start"/> to <see cref="CommonLineCutPath.End"/>, with the group's kerf.
-/// </summary>
-public sealed record CommonLinePerimeter(double Kerf, IReadOnlyList<CommonLineCutPath> SharedCuts);
-
-/// <summary>One shared cut on a common line's centerline, in part coordinates and cut direction.</summary>
-public sealed record CommonLineCutPath(Vector Start, Vector End);
-
 /// <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.
@@ -49,40 +36,15 @@ 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;
-    // 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;
     private readonly CuttingParameters[] contourParameters;
     private readonly int[] pinNumbers;
-    // Set when the support bed cannot hold the part level: the perimeter is tabbed and its
-    // automatic entries keep to points where the tab steadies the part. World = local + origin.
-    private readonly PartSupport support;
-    private readonly Vector supportOrigin;
-    // The outside when it is a display perimeter: shown and material, never cut. It is not one of
-    // the contours, so every contour is a hole; a complete emission only appends it as the
-    // never-executed DisplayPerimeterTail. Null for an ordinary cut perimeter.
-    private readonly Shape displayOutline;
-    private bool hasCutPerimeter => displayOutline == null;
-    // Set for a common-line member: the perimeter's shared spans are Tab entities, never cut by
-    // this part. It is cut as its shared cuts, then its remainder pieces, from one fixed entry.
-    private readonly CommonLinePerimeter commonLine;
-    private readonly ContourChoice commonLineEntry;
 
     private PreparedContours(Shape[] shapes, List<Entity> scribes, List<Shape> breakCuts, List<Shape> tabbedCutouts,
         CuttingParameters parameters)
-        : this(shapes, scribes, breakCuts, tabbedCutouts, parameters, displayOutline: null)
     {
-    }
-
-    private PreparedContours(Shape[] shapes, List<Entity> scribes, List<Shape> breakCuts, List<Shape> tabbedCutouts,
-        CuttingParameters parameters, Shape displayOutline, PierceZoneMemo pierceZones = null,
-        CommonLinePerimeter commonLine = null)
-    {
-        this.pierceZones = pierceZones ?? new PierceZoneMemo();
-        this.displayOutline = displayOutline;
-        this.commonLine = commonLine;
         this.shapes = shapes;
         this.scribes = scribes;
         this.breakCuts = breakCuts;
@@ -90,19 +52,10 @@ public sealed class PreparedContours
         this.parameters = parameters;
         pinned = new ContourChoice[shapes.Length];
         pinNumbers = new int[shapes.Length];
-        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,
+        : this(unpinned.shapes, unpinned.scribes, unpinned.breakCuts, unpinned.tabbedCutouts, unpinned.parameters)
-            unpinned.displayOutline, unpinned.pierceZones, unpinned.commonLine)
     {
         contourParameters = new CuttingParameters[shapes.Length];
         var rejected = new List<CutPinResolution>();
@@ -119,16 +72,13 @@ 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;
             }
-            var choice = new ContourChoice(contour, pin.EntityOrdinal,
+            var choice = new ContourChoice(contour, pin.EntityOrdinal, pin.Point) { Owner = this };
-                SnapToVertex(shapes[contour], pin.EntityOrdinal, pin.Point))
-            { Owner = this };
             ValidateChoice(choice);
             pinned[contour] = choice;
             pinNumbers[contour] = pin.PinIndex + 1;
@@ -137,97 +87,17 @@ public sealed class PreparedContours
         RejectedPins = rejected.AsReadOnly();
     }
 
-    // A copy that tabs the perimeter for support; every pin keeps its entry, now owned here, and
-    // 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)
-    {
-        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 = source.contourParameters == null
-            ? new CuttingParameters[Count]
-            : (CuttingParameters[])source.contourParameters.Clone();
-        if (pinned[PerimeterOrdinal] == null)
-        {
-            var perimeter = OwnedCuttingParameters.Copy(source.ParametersFor(PerimeterOrdinal));
-            perimeter.TabsEnabled = true;
-            perimeter.TabConfig = OwnedCuttingParameters.CopyTab(tab);
-            contourParameters[PerimeterOrdinal] = perimeter;
-        }
-        RejectedPins = source.RejectedPins;
-        this.support = support;
-        supportOrigin = location;
-    }
-
-    /// <summary>
-    /// A copy whose perimeter is tabbed with <paramref name="tab"/> where it steadies the part
-    /// on its support bed: <paramref name="support"/> analyzed this part's material placed at
-    /// <paramref name="location"/>, and the perimeter's automatic entries keep to points it
-    /// accepts (<see cref="PartSupport.AcceptsTabAt"/>) plus its best tab point. A pinned
-    /// perimeter keeps its pin's entry, leads and tab (the drawing wins); the copy only keeps
-    /// the analysis, so replay can report a pin that leaves the part unsteady.
-    /// </summary>
-    public PreparedContours WithSupportTab(PartSupport support, Vector location, Tab tab)
-    {
-        ArgumentNullException.ThrowIfNull(support);
-        ArgumentNullException.ThrowIfNull(tab);
-        PostVerificationGeometry.Validate(location);
-        if (!support.IsComplete || support.BestTabPoint == null)
-            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);
-    }
-
-    /// <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.
-    /// </summary>
-    public PartSupport Support => support;
-
-    /// <summary>The part's location: world = local + this, for <see cref="Support"/>.</summary>
-    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;
-
-    /// <summary>
-    /// True for a common-line member (see <see cref="CommonLinePerimeter"/>): its perimeter has one
-    /// fixed entry and is emitted as its shared cuts, then its remainder pieces.
-    /// </summary>
-    public bool IsCommonLinePerimeter => commonLine != null;
-
-    /// <summary>The member's shared cuts and kerf, 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();
+    public int PerimeterOrdinal => Count - 1;
 
-    /// <summary>The pierce-zone resolutions these contours' emissions share; for tests.</summary>
+    /// <summary>Resolved pins this preparation could not honour: a tab on an internal contour.</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.
-    /// </summary>
-    public int PerimeterOrdinal => hasCutPerimeter ? Count - 1 : Count;
-
-    /// <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>
     public IReadOnlyList<CutPinResolution> RejectedPins { get; } = Array.Empty<CutPinResolution>();
 
     /// <summary>True when a drawing pin fixes this contour's entry, leads and tab.</summary>
-    public bool IsPinned(int contourOrdinal) => !(contourOrdinal == PerimeterOrdinal && !hasCutPerimeter)
+    public bool IsPinned(int contourOrdinal) => GetShape(contourOrdinal) != null && pinned[contourOrdinal] != null;
-        && GetShape(contourOrdinal) != null && pinned[contourOrdinal] != null;
 
     /// <summary>The one-based drawing pin that fixes this contour, or null.</summary>
     public int? PinNumberOf(int contourOrdinal) => IsPinned(contourOrdinal) ? pinNumbers[contourOrdinal] : null;
@@ -245,22 +115,24 @@ 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;
     }
 
-    // The pin's leads replace both lead sets, since the type the emitter detects is
+    // The pin's leads replace every contour type's leads, since the type the emitter detects is
     // not the caller's concern; angle rounding is off because a pinned entry never moves.
     private static CuttingParameters PinParameters(CuttingParameters shared, ContourCutPin pin)
     {
         var owned = OwnedCuttingParameters.Copy(shared);
         owned.ExternalLeadIn = pin.LeadIn;
         owned.InternalLeadIn = pin.LeadIn;
+        owned.ArcCircleLeadIn = pin.LeadIn;
         owned.ExternalLeadOut = pin.LeadOut;
         owned.InternalLeadOut = pin.LeadOut;
+        owned.ArcCircleLeadOut = pin.LeadOut;
         owned.RoundLeadInAngles = false;
         owned.TabsEnabled = pin.HasTab;
         if (pin.HasTab)
@@ -270,11 +142,7 @@ public sealed class PreparedContours
 
     private CuttingParameters ParametersFor(int contourOrdinal) => contourParameters?[contourOrdinal] ?? parameters;
 
-    /// <param name="commonLine">For a common-line member: its shared cuts. The program's perimeter
+    public static PreparedContours Capture(Program program, CuttingParameters parameters, CancellationToken token = default)
-    /// must carry the member's shared spans 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);
@@ -287,7 +155,6 @@ public sealed class PreparedContours
         var scribes = new List<Entity>();
         var breakCuts = new List<Shape>();
         var tabbedCutouts = new List<Shape>();
-        Shape displayPerimeter = null;
         Shape breakCut = null;
         var current = new Shape();
         foreach (var entity in geometryProgram.ToGeometry())
@@ -318,8 +185,7 @@ public sealed class PreparedContours
                     scribes.Add(entity);
                 continue;
             }
-            if (entity.Layer != SpecialLayers.Cut && entity.Layer != SpecialLayers.Display && entity.Layer != SpecialLayers.Tab
+            if (entity.Layer != SpecialLayers.Cut && entity.Layer != SpecialLayers.Display && entity.Layer != SpecialLayers.Tab)
-                && entity.Layer != SpecialLayers.DisplayPerimeter)
                 throw new ArgumentException("Preparation requires clean cut/display contours.");
             if (entity.Length <= PostVerificationGeometry.Epsilon || !double.IsFinite(entity.Length))
                 throw new ArgumentException("Degenerate contour entity.");
@@ -337,62 +203,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.SharedCuts == null
-                || commonLine.SharedCuts.Any(c => c == null || c.Start.DistanceTo(c.End) <= PostVerificationGeometry.Epsilon))
-                throw new ArgumentException("A common-line member needs a positive kerf and nondegenerate shared cuts.");
-            // The outside carries the shared spans as tabs; every other contour lies inside it.
-            var outside = tabbedCutouts.Concat(contours).MaxBy(shape => shape.BoundingBox.Width * shape.BoundingBox.Length);
-            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 with { SharedCuts = commonLine.SharedCuts.ToArray() });
-        }
-        if (displayPerimeter != null)
-        {
-            if (current.Entities.Count != 0)
-                throw new ArgumentException("Preparation requires nonempty closed contours.");
-            if (contours.Count == 0 && tabbedCutouts.Count == 0 && breakCuts.Count == 0)
-                throw new ArgumentException("A display perimeter with no cutouts has nothing to cut.");
-            // Every cut must lie on the blank: a non-rectangular blank's box is not enough.
-            // Each cut is sampled along its arcs and must not cross or touch the outline anywhere.
-            var outline = displayPerimeter.ToPolygon();
-            foreach (var shape in contours.Concat(tabbedCutouts).Concat(breakCuts))
-                if (shape.ToPolygon().Vertices.Any(vertex => !outline.ContainsPoint(vertex))
-                    || displayPerimeter.Intersects(shape))
-                    throw new ArgumentException("A display perimeter must enclose every other contour.");
-            // The search plans a part through its closed contours; tabbed cutouts and break cuts
-            // alone leave it nothing to choose.
-            if (contours.Count == 0)
-                throw new ArgumentException("A display perimeter needs at least one closed cutout without tabs.");
-            foreach (var cut in breakCuts)
-                cut.UpdateBounds();
-            // Never a contour: nothing can choose, emit or lead it. Every contour is a hole.
-            return new(contours.ToArray(), scribes, breakCuts, tabbedCutouts, ownedParameters, displayPerimeter);
-        }
         if (current.Entities.Count != 0 || contours.Count == 0)
             throw new ArgumentException("Preparation requires nonempty closed contours.");
         var perimeter = 0;
@@ -413,15 +223,7 @@ public sealed class PreparedContours
         void FinishContour()
         {
             current.UpdateBounds();
-            if (current.Entities.Exists(e => e.Layer == SpecialLayers.DisplayPerimeter))
+            if (ContourCuttingStrategy.IsTabbedCutout(current))
-            {
-                if (!current.Entities.TrueForAll(e => e.Layer == SpecialLayers.DisplayPerimeter))
-                    throw new ArgumentException("A display perimeter must be one whole closed contour.");
-                if (displayPerimeter != null)
-                    throw new ArgumentException("A display perimeter must enclose every other contour.");
-                displayPerimeter = current;
-            }
-            else if (ContourCuttingStrategy.IsTabbedCutout(current))
             {
                 if (current.Entities.TrueForAll(e => e.Layer == SpecialLayers.Tab))
                     throw new ArgumentException("A tabbed cutout has nothing to cut.");
@@ -440,8 +242,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);
     }
@@ -460,8 +260,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++)
@@ -487,12 +285,8 @@ public sealed class PreparedContours
         void Add(int entityOrdinal, Vector point)
         {
             token.ThrowIfCancellationRequested();
-            if (entries.Count >= maxEntries)
+            if (entries.Count < maxEntries && !entries.Any(e => e.Point.DistanceTo(point) <= PostVerificationGeometry.Epsilon))
-                return;
+                entries.Add(Entry(contourOrdinal, entityOrdinal, point));
-            // Compare the entry as emitted: snapping can bring two raw points together.
-            var entry = Entry(contourOrdinal, entityOrdinal, point);
-            if (!entries.Any(e => e.Point.DistanceTo(entry.Point) <= PostVerificationGeometry.Epsilon))
-                entries.Add(entry);
         }
     }
 
@@ -517,7 +311,6 @@ public sealed class PreparedContours
 
     public ContourChoice Entry(int contourOrdinal, int entityOrdinal, Vector point)
     {
-        point = SnapToVertex(GetShape(contourOrdinal), entityOrdinal, point);
         var choice = new ContourChoice(contourOrdinal, entityOrdinal, point) { Owner = this };
         ValidateChoice(choice);
         return choice;
@@ -530,63 +323,12 @@ public sealed class PreparedContours
     /// emission reads only this choice and the perimeter, and the lead validator checks the
     /// lead as usual. A pinned perimeter keeps its pin's entry.
     /// </summary>
-    internal ContourChoice ScrapPierceEntry(Vector pierce) => PiercedEntry(PerimeterOrdinal, pierce);
+    internal ContourChoice ScrapPierceEntry(Vector pierce)
-
-    /// <summary>
-    /// Entries of cutout <paramref name="contourOrdinal"/> pierced where eroding it leaves room
-    /// (see <see cref="ErodedPierce"/>): the planner's fallback when no configured lead-in fits the
-    /// cutout. For each of the first <paramref name="max"/> <paramref name="targets"/> (its own
-    /// entries, usually ranked) the pierce is the eroded point nearest it, and the lead-in runs
-    /// straight from there to the target itself, then, as an alternative, to the cutout's native
-    /// point closest to the pierce. Neither has a lead-out. Nothing for the perimeter or a pinned
-    /// cutout; the lead validator still checks each one.
-    /// </summary>
-    internal IReadOnlyList<ContourChoice> ErodedPierceEntries(int contourOrdinal, IReadOnlyList<ContourChoice> targets,
-        int max, CancellationToken token = default)
-    {
-        token.ThrowIfCancellationRequested();
-        var shape = GetShape(contourOrdinal);
-        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(),
-            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++)
-        {
-            token.ThrowIfCancellationRequested();
-            var pierce = found.Pierces[i];
-            Add(() => targets[i] with { Pierce = pierce });
-            Add(() => PiercedEntry(contourOrdinal, pierce));
-        }
-        return entries;
-
-        void Add(Func<ContourChoice> entry)
-        {
-            try
-            {
-                var choice = entry();
-                ValidateChoice(choice);
-                if (!entries.Any(e => e.Point == choice.Point && e.Pierce == choice.Pierce))
-                    entries.Add(choice);
-            }
-            catch (ArgumentException)
-            {
-                // A pierce on the wall itself has no lead; the others still stand.
-            }
-        }
-    }
-
-    // A contour entry at the closest native point to a pierce off it, along a straight lead-in.
-    private ContourChoice PiercedEntry(int contourOrdinal, Vector pierce)
     {
         PostVerificationGeometry.Validate(pierce);
-        var shape = GetShape(contourOrdinal);
+        var shape = GetShape(PerimeterOrdinal);
         var point = shape.ClosestPointTo(pierce, out var entity);
-        point = SnapToVertex(shape, shape.Entities.IndexOf(entity), point);
+        var choice = new ContourChoice(PerimeterOrdinal, shape.Entities.IndexOf(entity), point)
-        var choice = new ContourChoice(contourOrdinal, shape.Entities.IndexOf(entity), point)
         {
             Owner = this,
             Pierce = pierce,
@@ -596,7 +338,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
@@ -611,15 +353,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);
+        return MergeByGeometry(PreferredCandidates(shape, contourOrdinal, token));
     }
 
     /// <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
@@ -627,63 +367,22 @@ 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,
         Vector? lookAhead = null,
-        CancellationToken token = default,
+        CancellationToken token = default)
-        SupportEntries supportEntries = SupportEntries.Steadying)
     {
         token.ThrowIfCancellationRequested();
         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);
         all.AddRange(FallbackCandidates(shape, contourOrdinal, lookAhead, token));
-        return SupportFiltered(contourOrdinal, all, supportEntries);
+        return MergeByGeometry(all);
-    }
-
-    /// <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.
-    /// </summary>
-    internal bool HasSupportTab => support != null && !IsPinned(PerimeterOrdinal);
-
-    /// <summary>
-    /// The support margin with this perimeter's tab at <paramref name="choice"/> (see
-    /// <see cref="PartSupport.MarginWith"/>); negative infinity when it is not tabbed for support.
-    /// </summary>
-    internal double SupportMarginAt(ContourChoice choice) =>
-        support?.MarginWith(choice.Point + supportOrigin) ?? double.NegativeInfinity;
-
-    /// <summary>Whether a support tab at <paramref name="choice"/> holds the part level (see <see cref="PartSupport.HoldsLevelWithTabAt"/>).</summary>
-    internal bool HoldsLevelAt(ContourChoice choice) =>
-        support != null && support.HoldsLevelWithTabAt(choice.Point + supportOrigin);
-
-    /// <summary>Whether a support tab at <paramref name="choice"/> keeps the inside-corner clearance.</summary>
-    internal bool IsClearOfInsideCorners(ContourChoice choice) =>
-        support == null || support.IsClearOfInsideCorners(choice.Point + supportOrigin);
-
-    // A perimeter tabbed for support keeps the candidates whose tab steadies the part, and gains
-    // the outline's best tab point. The search's fallbacks, when none of them has a lead-in that
-    // fits, keep every candidate clear of inside corners and then every candidate, still tabbed.
-    private IReadOnlyList<ContourEntryCandidate> SupportFiltered(int contourOrdinal,
-        List<ContourEntryCandidate> candidates, SupportEntries entries)
-    {
-        if (support == null || contourOrdinal != PerimeterOrdinal || entries == SupportEntries.Any)
-            return MergeByGeometry(candidates);
-        if (entries == SupportEntries.ClearOfInsideCorners)
-            return MergeByGeometry(candidates.Where(c => IsClearOfInsideCorners(c.Choice)).ToList());
-        var kept = candidates.Where(c => support.AcceptsTabAt(c.Choice.Point + supportOrigin)).ToList();
-        var best = ClosestEntry(PerimeterOrdinal, support.BestTabPoint!.Value - supportOrigin);
-        if (!IsForbiddenVertex(GetShape(PerimeterOrdinal), best.Point))
-            kept.Add(new ContourEntryCandidate(best, AutomaticEntryKind.SupportTab));
-        return MergeByGeometry(kept);
     }
 
     private static bool IsSingleCircle(Shape shape) =>
@@ -691,8 +390,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>
@@ -737,7 +436,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();
@@ -776,10 +475,9 @@ public sealed class PreparedContours
             var point = inward ? line.StartPoint + offset : line.EndPoint - offset;
             // Strictly inside the edge by projection parameter (distance alone loses the
             // sign when a short edge is overshoot): never the corner, never the far
-            // endpoint (where a reflex vertex might sit). Short edges omit the point. The
+            // endpoint (where a reflex vertex might sit). Short edges omit the point.
-            // margin is the vertex snap distance, so Entry cannot snap it onto either end.
             var t = (point.X - line.StartPoint.X) * direction.X + (point.Y - line.StartPoint.Y) * direction.Y;
-            if (t <= OpenNest.Math.Tolerance.Epsilon || t >= line.Length - OpenNest.Math.Tolerance.Epsilon)
+            if (t <= PostVerificationGeometry.Epsilon || t >= line.Length - PostVerificationGeometry.Epsilon)
                 return;
             fallbacks.Add(Fallback(entityOrdinal, point, AutomaticEntryKind.NearCorner));
         }
@@ -851,16 +549,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)
         {
@@ -875,7 +571,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);
@@ -884,72 +580,36 @@ 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 * System.Math.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>
     public Program Emit(IReadOnlyList<ContourChoice> choices)
     {
         Validate(choices, true);
-        return EmitOwned(choices, complete: true);
+        return EmitPrefix(choices);
     }
 
     /// <summary>
@@ -966,28 +626,21 @@ public sealed class PreparedContours
             throw new ArgumentException("Foreign contour choice.");
         ValidateChoice(choice);
         // Same owned clones as a real emission; the source shapes/settings are never used
-        // directly, so the probe cannot drift the preparation or mutate it. Isolated emission
+        // directly, so the probe cannot drift the preparation or mutate it.
-        // reads only the chosen contour and the contour count, so only that contour is cloned.
+        return new ContourCuttingStrategy { Parameters = parameters }.EmitCandidateIsolated(
-        var owned = new Shape[shapes.Length];
+            shapes.Select(s => (Shape)s.Clone()).ToArray(), scribes.Select(e => e.Clone()).ToList(), choice,
-        owned[choice.ContourOrdinal] = (Shape)shapes[choice.ContourOrdinal].Clone();
+            contourParameters);
-        return new ContourCuttingStrategy { Parameters = parameters, PierceZones = pierceZones }.EmitCandidateIsolated(
-            owned, scribes.Select(e => e.Clone()).ToList(), choice, contourParameters, PerimeterOrdinal, commonLine);
     }
 
     // Each prefix is a standalone owned program, including the same scribes and break cuts once.
     internal Program EmitPrefix(IReadOnlyList<ContourChoice> choices)
     {
         Validate(choices, false);
-        return EmitOwned(choices, complete: false);
+        return new ContourCuttingStrategy { Parameters = parameters }.EmitPrepared(
-    }
-
-    // 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(
             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,
+            tabbedCutouts.Select(s => (Shape)s.Clone()).ToList());
-            complete ? (Shape)displayOutline?.Clone() : null, commonLine);
+    }
 
     /// <summary>Open break cuts this preparation cuts before its contours.</summary>
     public int BreakCutCount => breakCuts.Count;
@@ -1007,10 +660,7 @@ 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 || commonLine != null)
-            return new(this, choices, expected, 0);
         var perimeter = ParametersFor(PerimeterOrdinal);
         return new(this, choices, expected, perimeter.TabsEnabled ? perimeter.TabConfig.Size : 0);
     }
@@ -1042,45 +692,36 @@ 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, after its shared cuts.
-        if (commonLineEntry != null && choice.ContourOrdinal == PerimeterOrdinal
-            && (choice.EntityOrdinal != commonLineEntry.EntityOrdinal || choice.Point != commonLineEntry.Point
-                || choice.Pierce != null))
-            throw new ArgumentException("A common-line member's perimeter is cut from its fixed entry.");
         if (choice.Pierce is { } pierce)
         {
             PostVerificationGeometry.Validate(pierce);
+            if (choice.ContourOrdinal != PerimeterOrdinal)
+                throw new ArgumentException("Only a perimeter entry can be pierced in scrap.");
             if (pierce.DistanceTo(choice.Point) <= PostVerificationGeometry.Epsilon)
-                throw new ArgumentException("A planner-placed pierce must lie off its contour.");
+                throw new ArgumentException("A scrap pierce must lie off its contour.");
         }
     }
 
-    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>
-    internal Box ContourBounds(int contourOrdinal) => GetShape(contourOrdinal).BoundingBox;
-
     /// <summary>
     /// Whether <paramref name="point"/> lies inside the internal contour <paramref name="contourOrdinal"/>.
     /// A routing hint only (chorded at the overlap check's tolerance), never a clearance verdict.
@@ -1092,33 +733,6 @@ public sealed class PreparedContours
             && shape.ToPolygonWithTolerance(PlateOverlapAnalyzer.ChordTolerance).ContainsPoint(point);
     }
 
-    /// <summary>
-    /// Emission splits a contour at its entry with <see cref="Arc.SplitAt"/>/<see cref="Line.SplitAt"/>,
-    /// 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.
-    /// </summary>
-    private static Vector SnapToVertex(Shape shape, int entityOrdinal, Vector point)
-    {
-        if (entityOrdinal < 0 || entityOrdinal >= shape.Entities.Count
-            || shape.Entities[entityOrdinal] is not (Line or Arc))
-            return point;
-        var entity = shape.Entities[entityOrdinal];
-        // Within the verifier's epsilon the entry already cuts the contour whole: leave it, so
-        // programs emitted before this snap (saved pinned entries) re-emit unchanged.
-        bool Snaps(Vector vertex)
-        {
-            var distance = point.DistanceTo(vertex);
-            return distance > PostVerificationGeometry.Epsilon && distance < OpenNest.Math.Tolerance.Epsilon;
-        }
-        var start = Start(entity);
-        if (point.DistanceTo(start) < OpenNest.Math.Tolerance.Epsilon)
-            return Snaps(start) ? start : point;
-        var end = End(entity);
-        return Snaps(end) ? end : point;
-    }
-
     private static Vector Start(Entity entity) => entity is Line line ? line.StartPoint : ((Arc)entity).StartPoint();
     private static Vector End(Entity entity) => entity is Line line ? line.EndPoint : ((Arc)entity).EndPoint();
 

OpenNest.Core/CNC/CuttingPlanning/ReleasedContourState.cs

@@ -12,50 +12,19 @@ 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.
-    private int partContours;
-    private bool partClosed;
 
     public ReleasedContourState() : this(true) { }
 
     /// <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,
-        };
         copy.obstacles.AddRange(obstacles);
         return copy;
     }
@@ -76,11 +45,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,39 +58,14 @@ 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>
-    /// Checks <paramref name="execution"/> as the continuation of the part the last check ended
-    /// in, as if that part's whole execution had been checked with these motions appended: the
-    /// findings are those the appended motions would add, and the state advances the same way.
-    /// It needs that part to have ended with every cut closed and nothing deferred, and the
-    /// continuation to open with a rapid and end the same way; otherwise the result is null and
-    /// this state must be discarded, and the caller checks the whole execution instead. Fixed
-    /// emissions and cutoffs are not continued.
-    /// </summary>
-    internal IReadOnlyList<PostVerificationFinding> Continue(OwnedExecution execution, Vector arrival,
-        int partNumber, CancellationToken token)
-    {
-        ArgumentNullException.ThrowIfNull(execution);
-        PostVerificationGeometry.Validate(arrival);
-        if (!partClosed || execution.Motions.Count == 0 || !execution.Motions[0].Rapid)
-            return null;
-        var moves = execution.Motions.ToArray();
-        moves[0] = moves[0].WithStart(arrival);
-        var findings = new List<PostVerificationFinding>();
-        AnalyzeMoves(moves, false, findings, 1, partNumber, token, contoursBefore: partContours);
-        return partClosed ? findings.AsReadOnly() : null;
     }
 
     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)
     {
         var current = new CutGroup();
         var unfinished = new List<CutGroup>();
@@ -136,44 +78,31 @@ public sealed class ReleasedContourState
         CutGroup previous = null;
         var deferred = new List<(List<PostVerificationFinding> Target, int Index, PostVerificationFinding Finding)>();
         var hasLead = false;
-        var contourNumber = contoursBefore;
+        var contourNumber = 0;
         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 has no nonzero placed lead-in motion.")
-                                : "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 +116,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));
@@ -205,31 +127,16 @@ public sealed class ReleasedContourState
                     // A rapid well clear of a contour's extent can neither cross nor touch it.
                     if (reach.IsClearOf(obstacle.Extent))
                         continue;
-                    // A rapid leaving an overcut departs from its retraced tail, which lies on the first
+                    if (PostVerificationGeometry.Crosses(start, move.End, obstacle.Curves, token))
-                    // cut only within the seam tolerance its arcs were matched at. Contact within that
+                        Add(new(PostVerificationKind.RapidCrossing, plate, part, obstacle.Part,
-                    // much of the departure is the departure itself.
+                            $"Direct XY rapid crosses or touches completed untabbed contour {obstacle.Contour} " +
-                    var from = start;
+                            $"of part {obstacle.Part}.")
-                    if (obstacle.OvercutEnd is { } tailEnd && tailEnd.DistanceTo(start) <= PostVerificationGeometry.Epsilon
+                        {
-                        && start.DistanceTo(move.End) > PostVerificationGeometry.RaySeamTolerance)
+                            Location = (start + move.End) * 0.5,
-                        from = start + (move.End - start) * (PostVerificationGeometry.RaySeamTolerance / start.DistanceTo(move.End));
+                            RapidStart = start,
-                    if (!PostVerificationGeometry.Crosses(from, move.End, obstacle.Curves, token))
+                            RapidEnd = move.End,
-                        continue;
+                            ContactPoints = PostVerificationGeometry.ContactPoints(start, move.End, obstacle.Curves, token)
-                    var crossing = new PostVerificationFinding(PostVerificationKind.RapidCrossing, plate, part,
+                        }, owned);
-                        obstacle.Part, (move.HeadRaised ? "Head-raised" : "Direct") + " XY rapid crosses or touches "
-                        + (obstacle.TabMayNotHold
-                            ? $"the tabbed outside of part {obstacle.Part}, which its tab may not hold level."
-                            : $"completed untabbed contour {obstacle.Contour} of part {obstacle.Part}."))
-                    {
-                        Location = (start + move.End) * 0.5,
-                        RapidStart = start,
-                        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 +157,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;
@@ -277,7 +179,7 @@ public sealed class ReleasedContourState
                     contourNumber++;
                     if (reportMissingLeadIns && !cutoff && !hasLead)
                         Add(new(PostVerificationKind.MissingLeadIn, plate, part, null,
-                            $"Cutting contour {contourNumber} is missing lead-in geometry.")
+                            $"Cutting contour {contourNumber} has no nonzero placed lead-in motion.")
                         { Location = move.Curve.Start }, owned);
                     hasLead = false;
                     // A rapid can pause/reposition without leaving any material gap.
@@ -299,27 +201,19 @@ public sealed class ReleasedContourState
                 // A completed contour becomes an obstacle immediately, not at part end.
                 if (PostVerificationGeometry.Closed(current.Curves))
                     Finish();
-                else if (OvercutClosure(current.Curves) is { } closing)
-                {
-                    current.OvercutEnd = current.Curves[^1].End;
-                    current.Curves[^1] = closing;
-                    Finish();
-                }
             }
         }
         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;
         var retained = !cutoff && (unfinished.Count > 1 || deferred.Count > 0)
-            && (remainders || unfinished.All(LeadsClearOpenEnds)
+            && unfinished.All(LeadsClearOpenEnds)
-                && OpenCutsEncloseNothing(closed, unfinished.Concat(otherOpen).Append(loose).ToList(), token));
+            && OpenCutsEncloseNothing(closed, unfinished.Concat(otherOpen).Append(loose).ToList(), token);
-        for (var i = deferred.Count - 1; i >= 0 && !retained; i--)
+        for (var i = deferred.Count - 1; i >= 0 && !(retained && proveOpenCuts); 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.
@@ -328,34 +222,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;
 
         void Add(PostVerificationFinding finding, bool fixedEmission)
         {
@@ -378,12 +244,10 @@ public sealed class ReleasedContourState
                 return;
             // A real uncut gap leaves the contour attached. CuttingParameters can be stale;
             // no flag or tab configuration is used as evidence of retention.
-            if (!cutoff && (current.OvercutEnd.HasValue || PostVerificationGeometry.Closed(current.Curves)))
+            if (!cutoff && PostVerificationGeometry.Closed(current.Curves))
             {
-                lastObstacle = new(part, contourNumber, current.Curves.ToArray(), current.OvercutEnd);
+                obstacles.Add(new(part, contourNumber, current.Curves.ToArray()));
-                obstacles.Add(lastObstacle);
                 closed.Add(current);
-                lastClosed = current;
             }
             else if (!cutoff)
                 unfinished.Add(current);
@@ -391,47 +255,12 @@ 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
-    /// cut passes back through the start and its tail retraces the first cut. The tail encloses
-    /// nothing, so the contour is closed by the last cut up to its start. Null for any other shape.
-    /// Arcs of one circle may carry centers derived from their own rounded endpoints, so the seam
-    /// is matched at <see cref="PostVerificationGeometry.RaySeamTolerance"/>, the closure seam
-    /// ray parity already admits; the obstacle keeps that seam, never the retraced tail.
-    /// </summary>
-    private static PostVerificationGeometry.Curve OvercutClosure(IReadOnlyList<PostVerificationGeometry.Curve> curves)
-    {
-        if (curves.Count < 2)
-            return null;
-        const double tolerance = PostVerificationGeometry.RaySeamTolerance;
-        var first = curves[0];
-        var last = curves[^1];
-        if (!last.SameDirection(first, tolerance) || !last.Contains(first.Start, tolerance)
-            || !first.Contains(last.End, tolerance))
-            return null;
-        var seam = last.ClosestPoint(first.Start);
-        var along = last.DistanceAlong(seam);
-        var tail = last.Length - along;
-        return along > tolerance && tail > tolerance && tail <= first.Length + tolerance ? last.Until(seam) : null;
-    }
-
     /// <summary>
     /// Whether one part's open cuts, with their leads, can release no material. A closed
     /// 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;
 
@@ -567,9 +396,6 @@ public sealed class ReleasedContourState
         internal List<PostVerificationGeometry.Curve> Curves { get; } = new();
         internal List<PostVerificationGeometry.Curve> Leads { get; } = new();
         internal bool Fixed { get; set; }
-        // Where the cut really ended when OvercutClosure closed it: the retraced tail's end, on the
-        // first cut. Its last curve now ends at the seam instead.
-        internal Vector? OvercutEnd { get; set; }
     }
 
     private sealed class DisjointSet(int count)
@@ -586,13 +412,9 @@ public sealed class ReleasedContourState
         internal void Union(int a, int b) => parents[Find(a)] = Find(b);
     }
 
-    private sealed record Obstacle(int Part, int Contour, IReadOnlyList<PostVerificationGeometry.Curve> Curves,
+    private sealed record Obstacle(int Part, int Contour, IReadOnlyList<PostVerificationGeometry.Curve> Curves)
-        Vector? OvercutEnd)
     {
         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

@@ -72,8 +72,8 @@ internal static class SeamOvercut
             // Incremental coordinates only need a consistent origin within one contour.
             var reference = incremental ? position ?? new Vector() : new Vector();
             var end = reference + motion.EndPoint;
-            var cut = !motion.Suppressed && motion is LinearMove { Layer: LayerType.Cut or LayerType.Display or LayerType.DisplayPerimeter }
+            var cut = !motion.Suppressed && motion is LinearMove { Layer: LayerType.Cut or LayerType.Display }
-                or ArcMove { Layer: LayerType.Cut or LayerType.Display or LayerType.DisplayPerimeter };
+                or ArcMove { Layer: LayerType.Cut or LayerType.Display };
             if (!cut || position == null)
             {
                 Finish();
@@ -160,7 +160,7 @@ 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 = System.Math.Atan2(from.Y - center.Y, from.X - center.X);

OpenNest.Core/CNC/CuttingPlanning/StateFingerprint.cs

@@ -83,17 +83,16 @@ internal static class StateFingerprint
             Out(p.ExternalLeadOut);
             Lead(p.InternalLeadIn);
             Out(p.InternalLeadOut);
+            Lead(p.ArcCircleLeadIn);
+            Out(p.ArcCircleLeadOut);
             Number(p.PierceClearance);
             Number(p.PierceDiameter);
             Flag(p.RoundLeadInAngles);
             Number(p.LeadInAngleIncrement);
+            Number(p.AutoTabMinSize);
+            Number(p.AutoTabMaxSize);
             TabSettings(p.TabConfig);
             Flag(p.TabsEnabled);
-            Flag(p.SupportTabs);
-            Flag(p.TabBySize);
-            Number(p.TabSizeMinWidth);
-            Number(p.TabSizeMaxWidth);
-            Number(p.TabHeldMaxLength);
             Sequence(p.Sequencing);
             Assignment(p.Assignment);
             text.Append('}');
@@ -142,7 +141,6 @@ internal static class StateFingerprint
                     break;
                 case ArcLeadIn l when Begin(lead, typeof(ArcLeadIn)):
                     Number(l.Radius);
-                    Number(l.SweepAngle);
                     break;
                 case LineArcLeadIn l when Begin(lead, typeof(LineArcLeadIn)):
                     Number(l.LineLength);

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)
@@ -26,7 +20,6 @@ namespace OpenNest.CNC.CuttingStrategy
         public CuttingResult Apply(Program partProgram, Vector approachPoint, Vector nextPartStart)
         {
             var entities = partProgram.ToGeometry();
-            RefuseDisplayPerimeter(entities);
             var breakCuts = TakeBreakCuts(entities);
             entities.RemoveAll(e => e.Layer == SpecialLayers.Rapid);
 
@@ -114,14 +107,6 @@ namespace OpenNest.CNC.CuttingStrategy
             return new CuttingResult { Program = result, LastCutPoint = perimeterPt };
         }
 
-        // These tools would lead the outline or mistake the largest cutout for it (an External lead
-        // pierced on the blank). Only the cutting planner knows every contour of such a part is a hole.
-        private static void RefuseDisplayPerimeter(List<Entity> entities)
-        {
-            if (entities.Exists(e => e.Layer == SpecialLayers.DisplayPerimeter))
-                throw new InvalidOperationException(DisplayPerimeterTail.LeadInRefusal);
-        }
-
         public CuttingResult ApplySingle(
             Program partProgram,
             Vector point,
@@ -130,7 +115,6 @@ namespace OpenNest.CNC.CuttingStrategy
         )
         {
             var entities = partProgram.ToGeometry();
-            RefuseDisplayPerimeter(entities);
             var breakCuts = TakeBreakCuts(entities);
             entities.RemoveAll(e => e.Layer == SpecialLayers.Rapid);
 
@@ -267,22 +251,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)
-            CuttingPlanning.CommonLinePerimeter commonLine = null)
         {
             var result = new Program(Mode.Absolute);
             EmitScribeContours(result, scribes);
             EmitBreakCuts(result, breakCuts, shapes);
             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);
-                commonLine);
-            if (displayTail != null)
-            {
-                // Display only, after every cut: executed reads and posts stop at its marker.
-                var start = GetShapeStartPoint(displayTail);
-                DisplayPerimeterTail.Append(result, ConvertShapeToMoves(displayTail, start, LayerType.DisplayPerimeter), start);
-            }
             result.Mode = Mode.Incremental;
             return result;
         }
@@ -293,58 +269,33 @@ namespace OpenNest.CNC.CuttingStrategy
         // perimeter never degrades to a hole because it was isolated. Output must not be
         // 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,
+            CuttingPlanning.ContourChoice choice, IReadOnlyList<CuttingParameters> contourParameters = null)
-            int? perimeterOrdinal = null, CuttingPlanning.CommonLinePerimeter commonLine = 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);
-                commonLine);
             result.Mode = Mode.Incremental;
             return result;
         }
 
-        // One contour per choice in order; the perimeter is always External. Without a cut perimeter
+        // One contour per choice in order; the perimeter (last shape) is always External.
-        // (a display perimeter outside) perimeterOrdinal is past the last shape: every contour is a hole.
         // Contour emission itself reads only the contour's own geometry and settings, never
         // prior choices — the differential tests in ContourCandidateEmissionTests pin this.
         private void EmitChosenContours(Program result, Shape[] shapes,
-            IReadOnlyList<CuttingPlanning.ContourChoice> choices, IReadOnlyList<CuttingParameters> contourParameters,
+            IReadOnlyList<CuttingPlanning.ContourChoice> choices, IReadOnlyList<CuttingParameters> contourParameters)
-            int perimeterOrdinal, CuttingPlanning.CommonLinePerimeter commonLine = null)
         {
             var shared = Parameters;
             try
             {
-                var inSlug = false;
                 foreach (var choice in choices)
                 {
-                    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 == shapes.Length - 1 ? ContourType.External : null,
-                        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
@@ -463,17 +414,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);
@@ -482,9 +430,6 @@ namespace OpenNest.CNC.CuttingStrategy
 
             var leadIn = SelectLeadIn(contourType);
             var leadOut = SelectLeadOut(contourType);
-            // A cutout the planner pierced by erosion is too small for its configured leads.
-            if (scrapPierce != null && contourType != ContourType.External)
-                leadOut = new NoLeadOut();
 
             if (contourType == ContourType.ArcCircle && entity is Circle circle)
             {
@@ -501,16 +446,9 @@ namespace OpenNest.CNC.CuttingStrategy
                     );
                 }
 
-                if (scrapPierce is { } holePierce)
+                leadIn = ClampLeadInForCircle(leadIn, circle, point, normal,
-                    leadIn = StraightLeadIn(point, holePierce, out normal);
+                    Parameters.GetEffectivePierceClearance());
-                else
+                leadIn = ResolvePierceZone(shape, point, leadIn, normal, Parameters.GetPierceZoneRadius());
-                {
-                    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);
-                }
 
                 // Build hole sub-program relative to (0,0)
                 var holeCenter = circle.Center;
@@ -527,8 +465,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
@@ -547,12 +484,10 @@ 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);
@@ -561,12 +496,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());
-                    if (stopAtCenterLine)
-                        leadIn = StopAtCenterLine(shape, point, leadIn, leadInNormal, turn);
-                    leadIn = PierceZone(memoContour, shape, point, leadIn, leadInNormal, turn);
-                }
             }
+            program.Codes.AddRange(leadIn.Generate(point, leadInNormal, winding));
 
             var reindexedShape = shape.ReindexAt(point, entity);
 
@@ -579,7 +511,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:
@@ -589,18 +520,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
@@ -609,24 +528,10 @@ 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, winding));
-            program.Codes.AddRange(leadOutCodes);
-            return contourType != ContourType.External && leadOutCodes.Count > 0;
         }
 
-        /// <summary>
-        /// The direction a lead arc turns to meet a contour of <paramref name="winding"/>
-        /// tangentially, in the cut direction. Normals point away from the material, so the arc
-        /// center lies outside an outside perimeter (turning against its winding) and inside a
-        /// cutout (turning with it).
-        /// </summary>
-        public static RotationType LeadTurn(ContourType contourType, RotationType winding) =>
-            contourType == ContourType.External
-                ? winding == RotationType.CW ? RotationType.CCW : RotationType.CW
-                : winding;
-
         private void EmitScribeContours(Program program, List<Entity> scribeEntities)
         {
             if (scribeEntities.Count == 0)
@@ -711,10 +616,8 @@ namespace OpenNest.CNC.CuttingStrategy
         /// <paramref name="pierceClearance"/> from the contour; the approach angle is
         /// ignored there. Otherwise it is perpendicular to the edge cut first, and at a
         /// reflex corner it bisects the notch. The result does not depend on which of
-        /// the two edges meeting at the corner was picked. A curved lead-in at a convex
+        /// the two edges meeting at the corner was picked. Other styles and contour
-        /// perimeter corner uses the normal of the edge cut first, so its arc meets that
+        /// types keep <see cref="ComputeLeadInNormal"/>.
-        /// edge tangentially. Other styles and contour types keep
-        /// <see cref="ComputeLeadInNormal"/>.
         /// </summary>
         public static LeadIn ResolveLeadIn(
             Shape shape,
@@ -728,19 +631,8 @@ namespace OpenNest.CNC.CuttingStrategy
         )
         {
             normal = ComputeLeadInNormal(shape, point, entity, contourType, leadIn, winding);
-            if (contourType != ContourType.External || !TryGetCorner(shape, point, entity, out var corner))
+            if (contourType != ContourType.External || leadIn is not LineLeadIn line
-                return leadIn;
+                || !TryGetCorner(shape, point, entity, out var corner))
-
-            if (leadIn is ArcLeadIn or LineArcLeadIn or CleanHoleLeadIn)
-            {
-                // The arc meets the edge cut first tangentially; its center sits off that edge,
-                // which at a convex corner keeps the whole arc clear of the part.
-                if (ClassifyCorner(corner, winding) is CornerKind.Convex or CornerKind.Smooth)
-                    normal = ComputeNormal(point, corner.Outgoing, contourType, winding);
-                return leadIn;
-            }
-
-            if (leadIn is not LineLeadIn line)
                 return leadIn;
 
             switch (ClassifyCorner(corner, winding))
@@ -770,8 +662,7 @@ namespace OpenNest.CNC.CuttingStrategy
         /// perimeter corner a <see cref="LineLeadOut"/> runs straight on past the corner
         /// along the edge cut last, when its end keeps <paramref name="clearance"/> from
         /// the contour; otherwise it is perpendicular to that edge. At a reflex corner it
-        /// bisects the notch. An <see cref="ArcLeadOut"/> at a convex corner uses the normal of
+        /// bisects the notch. Other styles and contour types keep the entity normal.
-        /// the edge cut last. Other styles and contour types keep the entity normal.
         /// </summary>
         public static LeadOut ResolveLeadOut(
             Shape shape,
@@ -785,18 +676,8 @@ namespace OpenNest.CNC.CuttingStrategy
         )
         {
             normal = ComputeNormal(point, entity, contourType, winding);
-            if (contourType != ContourType.External || !TryGetCorner(shape, point, entity, out var corner))
+            if (contourType != ContourType.External || leadOut is not LineLeadOut line
-                return leadOut;
+                || !TryGetCorner(shape, point, entity, out var corner))
-
-            if (leadOut is ArcLeadOut)
-            {
-                // The arc leaves the edge cut last tangentially.
-                if (ClassifyCorner(corner, winding) is CornerKind.Convex or CornerKind.Smooth)
-                    normal = ComputeNormal(point, corner.Incoming, contourType, winding);
-                return leadOut;
-            }
-
-            if (leadOut is not LineLeadOut line)
                 return leadOut;
 
             switch (ClassifyCorner(corner, winding))
@@ -923,18 +804,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)
@@ -963,46 +836,6 @@ namespace OpenNest.CNC.CuttingStrategy
             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 = System.Math.Cos(startNormal) + System.Math.Cos(endNormal);
-            var y = System.Math.Sin(startNormal) + System.Math.Sin(endNormal);
-            if (x * x + y * y <= Tolerance.Epsilon * Tolerance.Epsilon)
-                return null;
-
-            var normal = Angle.NormalizeRad(System.Math.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>
         /// A straight lead from <paramref name="end"/> to the corner stays in the scrap:
         /// its free end keeps <paramref name="clearance"/> from the contour and the lead
@@ -1112,7 +945,7 @@ namespace OpenNest.CNC.CuttingStrategy
             if (leadIn is NoLeadIn || clearance <= 0)
                 return leadIn;
 
-            var piercePoint = leadIn.GetPiercePoint(contourPoint, normalAngle, circle.Rotation);
+            var piercePoint = leadIn.GetPiercePoint(contourPoint, normalAngle);
             var maxRadius = circle.Radius - clearance;
             if (maxRadius <= 0)
                 return leadIn;
@@ -1154,30 +987,17 @@ 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
+        /// manual placement preview.
-        /// <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)
+            double pierceRadius)
         {
             if (pierceRadius <= 0 || !double.IsFinite(pierceRadius) || leadIn is NoLeadIn
                 || !hole.IsClosed())
@@ -1187,42 +1007,29 @@ 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)))
-            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);
@@ -1243,97 +1050,6 @@ 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(System.Math.Cos(normal), System.Math.Sin(normal));
-
         /// <summary>
         /// A straight lead-in from <paramref name="pierce"/> to <paramref name="point"/>, with the
         /// normal to generate it with.
@@ -1347,16 +1063,12 @@ namespace OpenNest.CNC.CuttingStrategy
         // 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
             {
-                ContourType.Internal or ContourType.ArcCircle => Parameters.InternalLeadIn,
+                ContourType.ArcCircle => Parameters.ArcCircleLeadIn ?? Parameters.InternalLeadIn,
+                ContourType.Internal => Parameters.InternalLeadIn,
                 _ => Parameters.ExternalLeadIn,
             };
         }
@@ -1365,29 +1077,14 @@ namespace OpenNest.CNC.CuttingStrategy
         {
             return contourType switch
             {
-                ContourType.Internal or ContourType.ArcCircle => Parameters.InternalLeadOut,
+                ContourType.ArcCircle => Parameters.ArcCircleLeadOut ?? Parameters.InternalLeadOut,
+                ContourType.Internal => Parameters.InternalLeadOut,
                 _ => Parameters.ExternalLeadOut,
             };
         }
 
         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 * System.Math.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);
 
@@ -1564,7 +1261,7 @@ namespace OpenNest.CNC.CuttingStrategy
         }
 
         /// <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>
@@ -1580,89 +1277,6 @@ namespace OpenNest.CNC.CuttingStrategy
                 : (start, startScrap, false);
         }
 
-        /// <summary>
-        /// A common-line member's outside, cut once per shared edge (docs/common-line-cutting.md):
-        /// first each shared cut the member owns, an open centerline cut entered and left along
-        /// its own axis with straight leads as long as the external lead-in's and lead-out's
-        /// reach; then each remainder piece (the perimeter between its shared spans, which lie
-        /// on the Tab layer) in the perimeter's own direction. A 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 leadOut = Parameters?.ExternalLeadOut ?? new NoLeadOut();
-            foreach (var cut in commonLine.SharedCuts)
-                program.Codes.AddRange(CommonLineSharedCutCodes(cut, leadIn, leadOut));
-            var entities = perimeter.Entities;
-            foreach (var piece in TabbedCutoutPieces(perimeter))
-            {
-                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>
-        /// One shared cut, absolute in its part's frame: a rapid to the pierce on the cut's axis
-        /// before its start, the straight lead-in, the open centerline cut and the straight
-        /// lead-out on past its end, each lead as long as the configured one reaches.
-        /// </summary>
-        internal static List<ICode> CommonLineSharedCutCodes(CuttingPlanning.CommonLineCutPath cut, LeadIn leadIn,
-            LeadOut leadOut)
-        {
-            var codes = new List<ICode>();
-            var along = (cut.End - cut.Start).Normalize();
-            var reach = CommonLineLeadInReach(leadIn);
-            codes.Add(new RapidMove(cut.Start - along * reach));
-            if (reach > Tolerance.Epsilon)
-                codes.Add(new LinearMove(cut.Start) { Layer = LayerType.Leadin });
-            codes.Add(new LinearMove(cut.End) { Layer = LayerType.CommonLine });
-            var exit = CommonLineLeadOutReach(leadOut);
-            if (exit > Tolerance.Epsilon)
-                codes.Add(new LinearMove(cut.End + along * exit) { Layer = LayerType.Leadout });
-            return codes;
-        }
-
-        /// <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>How far a common-line shared cut's lead-out reaches: the external lead-out's.</summary>
-        internal static double CommonLineLeadOutReach(LeadOut leadOut)
-        {
-            var reach = 0.0;
-            foreach (var code in leadOut.Generate(Vector.Zero, 0, RotationType.CW))
-                if (code is Motion motion)
-                    reach = System.Math.Max(reach, motion.EndPoint.DistanceTo(Vector.Zero));
-            return reach;
-        }
-
         /// <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);
 
@@ -1737,7 +1351,7 @@ namespace OpenNest.CNC.CuttingStrategy
                     return mirrored;
             }
             // Reaching both ways, or tangent to an arc: pierce straight in from the same distance.
-            var pierce = leadIn.GetPiercePoint(entry, normal, winding);
+            var pierce = leadIn.GetPiercePoint(entry, normal);
             return new LineLeadIn { Length = pierce.DistanceTo(entry), ApproachAngle = 90 }.Generate(entry, normal, winding);
         }
 

OpenNest.Core/CNC/CuttingStrategy/CuttingParameters.cs

@@ -15,14 +15,13 @@ namespace OpenNest.CNC.CuttingStrategy
         public LeadIn ExternalLeadIn { get; set; } = new NoLeadIn();
         public LeadOut ExternalLeadOut { get; set; } = new NoLeadOut();
 
-        /// <summary>
-        /// The lead-in of every cutout, full circles included; circles still get their own
-        /// geometry handling (radius clamp, angle rounding) when the lead is emitted.
-        /// </summary>
         public LeadIn InternalLeadIn { get; set; } =
             new LineLeadIn { Length = 0.125, ApproachAngle = 90 };
         public LeadOut InternalLeadOut { get; set; } = new NoLeadOut();
 
+        public LeadIn ArcCircleLeadIn { get; set; } = new NoLeadIn();
+        public LeadOut ArcCircleLeadOut { get; set; } = new NoLeadOut();
+
         public double PierceClearance { get; set; } = 0.0625;
 
         /// <summary>
@@ -41,70 +40,12 @@ namespace OpenNest.CNC.CuttingStrategy
         public bool RoundLeadInAngles { get; set; }
         public double LeadInAngleIncrement { get; set; } = 5.0;
 
+        public double AutoTabMinSize { get; set; }
+        public double AutoTabMaxSize { get; set; }
+
         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"/>
-        /// 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, or on a
-        /// 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
-        /// in <see cref="TabSizeMinWidth"/> to <see cref="TabSizeMaxWidth"/>
-        /// (<see cref="TabsBySizeAt"/>).
-        /// </summary>
-        public bool TabBySize { get; set; }
-
-        /// <summary>
-        /// The narrowest part width that is tabbed by size: with <see cref="TabBySize"/>, or with
-        /// <see cref="SupportTabs"/> on a plate that has no support bed (see <see cref="TabsBySizeAt"/>).
-        /// </summary>
-        public double TabSizeMinWidth { get; set; }
-
-        /// <summary>
-        /// The widest part width that is tabbed by size; 0 turns the rule off, so nothing is
-        /// tabbed by size.
-        /// </summary>
-        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.
-        /// </summary>
-        public bool TabsBySizeAt(double width) =>
-            HasTabSizeRange()
-            && width >= TabSizeMinWidth - Math.Tolerance.Epsilon
-            && width <= TabSizeMaxWidth + 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.
-        /// </summary>
-        public double TabHeldMaxLength { get; set; } = 6;
-
-        /// <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;
-
         public SequenceParameters Sequencing { get; set; } = new SequenceParameters();
         public AssignmentParameters Assignment { get; set; } = new AssignmentParameters();
     }

OpenNest.Core/CNC/CuttingStrategy/ErodedPierce.cs

@@ -1,143 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Clipper2Lib;
-using OpenNest.Geometry;
-
-namespace OpenNest.CNC.CuttingStrategy
-{
-    /// <summary>
-    /// Pierces found by eroding a cutout: the part of it that keeps a clearance from its wall
-    /// (see <see cref="ErodedPierce.Find"/>).
-    /// </summary>
-    /// <param name="Pierces">The pierce for each target in turn, up to the maximum asked for.</param>
-    /// <param name="Clearance">The least any pierce keeps from the wall, at the erosion level that found it.</param>
-    public sealed record ErodedPierces(IReadOnlyList<Vector> Pierces, double Clearance)
-    {
-        public static ErodedPierces None { get; } = new(System.Array.Empty<Vector>(), 0);
-    }
-
-    /// <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
-    /// to its pole of inaccessibility; a round hole is pierced at its center. 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
-    /// 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>
-    public static class ErodedPierce
-    {
-        /// <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
-        /// cutout is about as wide as its widest.
-        /// </summary>
-        public const double DepthFraction = 0.9;
-
-        private const int PoleSearchCells = 4096;
-
-        // Shallower erosion levels a target may fall back to, each a tenth of the deepest less.
-        private const int LevelCount = 6;
-        private const double LevelStep = 0.1;
-
-        /// <summary>
-        /// A pierce in the closed cutout <paramref name="hole"/> for each of the first
-        /// <paramref name="max"/> <paramref name="targets"/>: the eroded point nearest it. A cutout
-        /// 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)
-        {
-            if (hole == null || !hole.IsClosed() || targets == null || targets.Count == 0 || max <= 0
-                || !double.IsFinite(depth))
-                return ErodedPierces.None;
-
-            // The inscribed radius, from the true wall: the deepest any erosion can go.
-            var coarse = ClipperBridge.Flatten(hole, Tolerance(hole.BoundingBox.Width, hole.BoundingBox.Length), false);
-            if (coarse.Vertices.Count < 3)
-                return ErodedPierces.None;
-            var pole = PolyLabel.Find(coarse, null, Tolerance(coarse.BoundingBox.Width, coarse.BoundingBox.Length) / 10,
-                PoleSearchCells);
-            if (!double.IsFinite(pole.X) || !double.IsFinite(pole.Y) || !coarse.ContainsPoint(pole))
-                return ErodedPierces.None;
-            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 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)
-                return new(targets.Take(max).Select(_ => pole).ToArray(), inscribed);
-
-            var polygon = ClipperBridge.Flatten(hole, tolerance, circumscribe: false);
-            var path = new PathsD { ClipperBridge.ToPath(polygon, positive: true) };
-            var levels = new List<PathD>[LevelCount];
-            List<PathD> Level(int level) => levels[level] ??= Clipper.InflatePaths(path,
-                -(Depth(level) + margin), JoinType.Round, EndType.Polygon, 2.0, ClipperBridge.Precision, tolerance)
-                .Where(p => p.Count >= 3).ToList();
-            double Depth(int level) => depth * (1 - level * LevelStep);
-            if (Level(0).Count == 0)
-                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
-            // the entry, rather than only at the widest place.
-            var pierces = new List<Vector>();
-            var shallowest = depth;
-            foreach (var target in targets)
-            {
-                var pierce = Nearest(Level(0), target);
-                var reached = 0;
-                for (var level = 0; level < LevelCount; level++)
-                {
-                    var region = Level(level);
-                    if (region.Count == 0)
-                        continue;
-                    var nearest = Nearest(region, target);
-                    if (nearest.DistanceTo(target) <= 2 * (Depth(level) + margin))
-                    {
-                        pierce = nearest;
-                        reached = level;
-                        break;
-                    }
-                }
-                pierces.Add(pierce);
-                shallowest = System.Math.Min(shallowest, Depth(reached));
-                if (pierces.Count == max)
-                    break;
-            }
-            return new(pierces, shallowest);
-        }
-
-        // A hundredth of the smaller side: fine enough to find a thin cutout's pole.
-        private static double Tolerance(double width, double length) =>
-            System.Math.Max(System.Math.Min(width, length) / 100, System.Math.Pow(10, -ClipperBridge.Precision));
-
-        // The closest point of the region's boundary; targets lie on the wall, outside it.
-        private static Vector Nearest(List<PathD> paths, Vector target)
-        {
-            var best = default(Vector);
-            var bestDistance = double.PositiveInfinity;
-            foreach (var path in paths)
-                for (var i = 0; i < path.Count; i++)
-                {
-                    var a = new Vector(path[i].x, path[i].y);
-                    var b = new Vector(path[(i + 1) % path.Count].x, path[(i + 1) % path.Count].y);
-                    var point = new Line(a, b).ClosestPointTo(target);
-                    var distance = point.DistanceTo(target);
-                    if (distance < bestDistance)
-                    {
-                        bestDistance = distance;
-                        best = point;
-                    }
-                }
-            return best;
-        }
-    }
-}

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

@@ -1,62 +1,43 @@
 using System.Collections.Generic;
 using OpenNest.Geometry;
-using OpenNest.Math;
 
 namespace OpenNest.CNC.CuttingStrategy
 {
-    /// <summary>
-    /// A single arc that ends tangent to the cut. Its center lies <see cref="Radius"/> along the
-    /// contour normal and it turns <see cref="SweepAngle"/> degrees in the lead's turn direction:
-    /// 90 is a quarter circle, 180 (the default) a half circle starting two radii out.
-    /// </summary>
     public class ArcLeadIn : LeadIn
     {
-        public const double DefaultSweepAngle = 180.0;
-
         public double Radius { get; set; }
 
-        /// <summary>Degrees of arc, in (0, 180].</summary>
-        public double SweepAngle { get; set; } = DefaultSweepAngle;
-
         public override List<ICode> Generate(
             Vector contourStartPoint,
             double contourNormalAngle,
             RotationType winding = RotationType.CW
         )
         {
+            var piercePoint = GetPiercePoint(contourStartPoint, contourNormalAngle);
+
+            var arcCenter = new Vector(
+                contourStartPoint.X + Radius * System.Math.Cos(contourNormalAngle),
+                contourStartPoint.Y + Radius * System.Math.Sin(contourNormalAngle)
+            );
+
             return new List<ICode>
             {
-                new RapidMove(GetPiercePoint(contourStartPoint, contourNormalAngle, winding)),
+                new RapidMove(piercePoint),
-                new ArcMove(contourStartPoint, ArcCenter(contourStartPoint, contourNormalAngle), winding)
+                new ArcMove(contourStartPoint, arcCenter, winding) { Layer = LayerType.Leadin },
-                {
-                    Layer = LayerType.Leadin,
-                },
             };
         }
 
-        public override Vector GetPiercePoint(
+        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
-            Vector contourStartPoint,
-            double contourNormalAngle,
-            RotationType winding = RotationType.CW
-        )
         {
-            // The contour point sits opposite the normal from the center; the pierce is the
+            var arcCenterX = contourStartPoint.X + Radius * System.Math.Cos(contourNormalAngle);
-            // sweep back from there, against the turn. A half circle pierces on the normal.
+            var arcCenterY = contourStartPoint.Y + Radius * System.Math.Sin(contourNormalAngle);
-            var shortfall = Angle.ToRadians(DefaultSweepAngle - SweepAngle);
+
-            var angle = contourNormalAngle + (winding == RotationType.CCW ? shortfall : -shortfall);
-            var center = ArcCenter(contourStartPoint, contourNormalAngle);
             return new Vector(
-                center.X + Radius * System.Math.Cos(angle),
+                arcCenterX + Radius * System.Math.Cos(contourNormalAngle),
-                center.Y + Radius * System.Math.Sin(angle)
+                arcCenterY + Radius * System.Math.Sin(contourNormalAngle)
             );
         }
 
-        public override LeadIn Scale(double factor) =>
+        public override LeadIn Scale(double factor) => new ArcLeadIn { Radius = Radius * factor };
-            new ArcLeadIn { Radius = Radius * factor, SweepAngle = SweepAngle };
-
-        private Vector ArcCenter(Vector contourStartPoint, double contourNormalAngle) => new Vector(
-            contourStartPoint.X + Radius * System.Math.Cos(contourNormalAngle),
-            contourStartPoint.Y + Radius * System.Math.Sin(contourNormalAngle)
-        );
     }
 }

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

@@ -1,12 +1,11 @@
 using System.Collections.Generic;
 using OpenNest.Geometry;
+using OpenNest.Math;
 
 namespace OpenNest.CNC.CuttingStrategy
 {
     public class CleanHoleLeadIn : LeadIn
     {
-        private const double ApproachAngle = 135.0;
-
         public double LineLength { get; set; }
         public double ArcRadius { get; set; }
         public double Kerf { get; set; }
@@ -15,11 +14,42 @@ namespace OpenNest.CNC.CuttingStrategy
             Vector contourStartPoint,
             double contourNormalAngle,
             RotationType winding = RotationType.CW
-        ) => Approach(contourStartPoint, contourNormalAngle, winding).ToCodes(contourStartPoint, winding);
+        )
+        {
+            var piercePoint = GetPiercePoint(contourStartPoint, contourNormalAngle);
 
-        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle,
+            var arcCenterX = contourStartPoint.X + ArcRadius * System.Math.Cos(contourNormalAngle);
-            RotationType winding = RotationType.CW) =>
+            var arcCenterY = contourStartPoint.Y + ArcRadius * System.Math.Sin(contourNormalAngle);
-            Approach(contourStartPoint, contourNormalAngle, winding).PiercePoint;
+            var arcCenter = new Vector(arcCenterX, arcCenterY);
+
+            var lineAngle = contourNormalAngle + Angle.ToRadians(135.0);
+            var arcStart = new Vector(
+                arcCenterX + ArcRadius * System.Math.Cos(lineAngle),
+                arcCenterY + ArcRadius * System.Math.Sin(lineAngle)
+            );
+
+            return new List<ICode>
+            {
+                new RapidMove(piercePoint),
+                new LinearMove(arcStart) { Layer = LayerType.Leadin },
+                new ArcMove(contourStartPoint, arcCenter, winding) { Layer = LayerType.Leadin },
+            };
+        }
+
+        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
+        {
+            var arcCenterX = contourStartPoint.X + ArcRadius * System.Math.Cos(contourNormalAngle);
+            var arcCenterY = contourStartPoint.Y + ArcRadius * System.Math.Sin(contourNormalAngle);
+
+            var lineAngle = contourNormalAngle + Angle.ToRadians(135.0);
+            var arcStartX = arcCenterX + ArcRadius * System.Math.Cos(lineAngle);
+            var arcStartY = arcCenterY + ArcRadius * System.Math.Sin(lineAngle);
+
+            return new Vector(
+                arcStartX + LineLength * System.Math.Cos(lineAngle),
+                arcStartY + LineLength * System.Math.Sin(lineAngle)
+            );
+        }
 
         public override LeadIn Scale(double factor) =>
             new CleanHoleLeadIn
@@ -28,8 +58,5 @@ namespace OpenNest.CNC.CuttingStrategy
                 ArcRadius = ArcRadius * factor,
                 Kerf = Kerf,
             };
-
-        private LineArcApproach Approach(Vector contourStartPoint, double contourNormalAngle, RotationType winding) =>
-            LineArcApproach.Create(contourStartPoint, contourNormalAngle, ArcRadius, ApproachAngle, LineLength, winding);
     }
 }

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

@@ -3,11 +3,6 @@ using OpenNest.Geometry;
 
 namespace OpenNest.CNC.CuttingStrategy
 {
-    /// <summary>
-    /// A lead into a contour point. <c>winding</c> is the direction a lead arc turns to meet the
-    /// cut tangentially: the cut's own direction around the arc center, which lies along the
-    /// normal (see <see cref="ContourCuttingStrategy.LeadTurn"/>). Straight styles ignore it.
-    /// </summary>
     public abstract class LeadIn
     {
         public abstract List<ICode> Generate(
@@ -16,8 +11,7 @@ namespace OpenNest.CNC.CuttingStrategy
             RotationType winding = RotationType.CW
         );
 
-        public abstract Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle,
+        public abstract Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle);
-            RotationType winding = RotationType.CW);
 
         public virtual LeadIn Scale(double factor) => this;
     }

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

@@ -1,58 +0,0 @@
-using System.Collections.Generic;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.CNC.CuttingStrategy
-{
-    /// <summary>
-    /// A straight line into an arc that ends on the contour start, shared by
-    /// <see cref="LineArcLeadIn"/> and <see cref="CleanHoleLeadIn"/>. The arc's center lies
-    /// the arc radius along the contour normal; the line meets the arc at the approach angle
-    /// (degrees from the normal, on the side the arc turns from) and starts at the pierce point.
-    /// </summary>
-    internal readonly struct LineArcApproach
-    {
-        private LineArcApproach(Vector arcCenter, Vector arcStart, Vector piercePoint)
-        {
-            ArcCenter = arcCenter;
-            ArcStart = arcStart;
-            PiercePoint = piercePoint;
-        }
-
-        public Vector ArcCenter { get; }
-
-        public Vector ArcStart { get; }
-
-        public Vector PiercePoint { get; }
-
-        public static LineArcApproach Create(Vector contourStartPoint, double contourNormalAngle,
-            double arcRadius, double approachAngle, double lineLength, RotationType winding)
-        {
-            var arcCenterX = contourStartPoint.X + arcRadius * System.Math.Cos(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 * System.Math.Cos(lineAngle);
-            var arcStartY = arcCenterY + arcRadius * System.Math.Sin(lineAngle);
-
-            return new LineArcApproach(
-                new Vector(arcCenterX, arcCenterY),
-                new Vector(arcStartX, arcStartY),
-                new Vector(
-                    arcStartX + lineLength * System.Math.Cos(lineAngle),
-                    arcStartY + lineLength * System.Math.Sin(lineAngle)));
-        }
-
-        /// <summary>Rapid to the pierce point, then the line and arc on the lead-in layer.</summary>
-        public List<ICode> ToCodes(Vector contourStartPoint, RotationType winding) =>
-            new List<ICode>
-            {
-                new RapidMove(PiercePoint),
-                new LinearMove(ArcStart) { Layer = LayerType.Leadin },
-                new ArcMove(contourStartPoint, ArcCenter, winding) { Layer = LayerType.Leadin },
-            };
-    }
-}

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

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using OpenNest.Geometry;
+using OpenNest.Math;
 
 namespace OpenNest.CNC.CuttingStrategy
 {
@@ -13,11 +14,42 @@ namespace OpenNest.CNC.CuttingStrategy
             Vector contourStartPoint,
             double contourNormalAngle,
             RotationType winding = RotationType.CW
-        ) => Approach(contourStartPoint, contourNormalAngle, winding).ToCodes(contourStartPoint, winding);
+        )
+        {
+            var piercePoint = GetPiercePoint(contourStartPoint, contourNormalAngle);
 
-        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle,
+            var arcCenterX = contourStartPoint.X + ArcRadius * System.Math.Cos(contourNormalAngle);
-            RotationType winding = RotationType.CW) =>
+            var arcCenterY = contourStartPoint.Y + ArcRadius * System.Math.Sin(contourNormalAngle);
-            Approach(contourStartPoint, contourNormalAngle, winding).PiercePoint;
+            var arcCenter = new Vector(arcCenterX, arcCenterY);
+
+            var lineAngle = contourNormalAngle + Angle.ToRadians(ApproachAngle);
+            var arcStart = new Vector(
+                arcCenterX + ArcRadius * System.Math.Cos(lineAngle),
+                arcCenterY + ArcRadius * System.Math.Sin(lineAngle)
+            );
+
+            return new List<ICode>
+            {
+                new RapidMove(piercePoint),
+                new LinearMove(arcStart) { Layer = LayerType.Leadin },
+                new ArcMove(contourStartPoint, arcCenter, winding) { Layer = LayerType.Leadin },
+            };
+        }
+
+        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
+        {
+            var arcCenterX = contourStartPoint.X + ArcRadius * System.Math.Cos(contourNormalAngle);
+            var arcCenterY = contourStartPoint.Y + ArcRadius * System.Math.Sin(contourNormalAngle);
+
+            var lineAngle = contourNormalAngle + Angle.ToRadians(ApproachAngle);
+            var arcStartX = arcCenterX + ArcRadius * System.Math.Cos(lineAngle);
+            var arcStartY = arcCenterY + ArcRadius * System.Math.Sin(lineAngle);
+
+            return new Vector(
+                arcStartX + LineLength * System.Math.Cos(lineAngle),
+                arcStartY + LineLength * System.Math.Sin(lineAngle)
+            );
+        }
 
         public override LeadIn Scale(double factor) =>
             new LineArcLeadIn
@@ -26,8 +58,5 @@ namespace OpenNest.CNC.CuttingStrategy
                 ArcRadius = ArcRadius * factor,
                 ApproachAngle = ApproachAngle,
             };
-
-        private LineArcApproach Approach(Vector contourStartPoint, double contourNormalAngle, RotationType winding) =>
-            LineArcApproach.Create(contourStartPoint, contourNormalAngle, ArcRadius, ApproachAngle, LineLength, winding);
     }
 }

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

@@ -24,8 +24,7 @@ namespace OpenNest.CNC.CuttingStrategy
             };
         }
 
-        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle,
+        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
-            RotationType winding = RotationType.CW)
         {
             var approachAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle);
             return new Vector(

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

@@ -33,8 +33,7 @@ namespace OpenNest.CNC.CuttingStrategy
             };
         }
 
-        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle,
+        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
-            RotationType winding = RotationType.CW)
         {
             var secondAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle1);
             var midX = contourStartPoint.X + Length2 * System.Math.Cos(secondAngle);

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

@@ -14,8 +14,7 @@ namespace OpenNest.CNC.CuttingStrategy
             return new List<ICode> { new RapidMove(contourStartPoint) };
         }
 
-        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle,
+        public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
-            RotationType winding = RotationType.CW)
         {
             return contourStartPoint;
         }

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

@@ -3,10 +3,6 @@ using OpenNest.Geometry;
 
 namespace OpenNest.CNC.CuttingStrategy
 {
-    /// <summary>
-    /// A quarter circle leaving the cut tangentially, turning <c>winding</c> about a center
-    /// <see cref="Radius"/> along the contour normal.
-    /// </summary>
     public class ArcLeadOut : LeadOut
     {
         public double Radius { get; set; }
@@ -21,12 +17,9 @@ namespace OpenNest.CNC.CuttingStrategy
             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 * System.Math.Cos(endAngle),
+                arcCenterX + Radius * System.Math.Cos(contourNormalAngle + System.Math.PI / 2),
-                arcCenterY + Radius * System.Math.Sin(endAngle)
+                arcCenterY + Radius * System.Math.Sin(contourNormalAngle + System.Math.PI / 2)
             );
 
             return new List<ICode>

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/DisplayPerimeterTail.cs

@@ -1,158 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Geometry;
-
-namespace OpenNest.CNC
-{
-    /// <summary>
-    /// The never-cut outline of a supplied blank, kept at the end of an applied cutting program.
-    /// An applied program for a blank with a <see cref="LayerType.DisplayPerimeter"/> outline cuts
-    /// only its cutouts; the outline follows them after <see cref="Marker"/> so the part keeps the
-    /// blank's extent for bounds, overlap and cut-offs. Nothing that executes or posts a program may
-    /// run the tail: executed reads stop at the marker and posts take <see cref="ForPosting"/>.
-    /// </summary>
-    public static class DisplayPerimeterTail
-    {
-        /// <summary>The comment that starts the tail; every code after it is display only.</summary>
-        public const string Marker = "DISPLAY PERIMETER NEVER CUT";
-
-        /// <summary>Why the manual and legacy lead-in tools leave a display-perimeter part alone.</summary>
-        public const string LeadInRefusal =
-            "This part's outline is a display perimeter: a supplied blank that is never cut. "
-            + "Lead-ins for its cutouts come from Plan Cutting, which keeps every pierce inside a cutout.";
-
-        /// <summary>
-        /// The index of the tail's marker in <paramref name="program"/>'s codes, or -1. A marker that is
-        /// repeated, sits in a sub-program, or is followed by anything but one rapid and moves on the
-        /// display perimeter layer is a malformed program (<see cref="ArgumentException"/>): cuts after
-        /// it must never be dropped silently.
-        /// </summary>
-        public static int IndexOf(Program program)
-        {
-            ArgumentNullException.ThrowIfNull(program);
-            var marker = -1;
-            for (var i = 0; i < program.Codes.Count; i++)
-            {
-                if (program.Codes[i] is Comment { Value: Marker })
-                {
-                    if (marker >= 0)
-                        throw new ArgumentException("A program has more than one display perimeter tail.");
-                    marker = i;
-                }
-                else if (program.Codes[i] is SubProgramCall call
-                    && HasMarker(call.Program, new HashSet<Program>(ReferenceEqualityComparer.Instance)))
-                    throw new ArgumentException("A display perimeter tail can only end the part's own program, not a sub-program.");
-            }
-            if (marker < 0)
-                return -1;
-            var tail = program.Codes.Count - marker - 1;
-            if (tail < 2 || program.Codes[marker + 1] is not RapidMove
-                || !program.Codes.Skip(marker + 2).All(code =>
-                    code is LinearMove { Layer: LayerType.DisplayPerimeter } or ArcMove { Layer: LayerType.DisplayPerimeter }))
-                throw new ArgumentException(
-                    "A display perimeter tail must be one rapid followed only by the outline on the display perimeter layer.");
-            return marker;
-        }
-
-        private static bool HasMarker(Program program, HashSet<Program> visited)
-        {
-            if (program?.Codes == null || !visited.Add(program))
-                return false;
-            foreach (var code in program.Codes)
-                if (code is Comment { Value: Marker } || code is SubProgramCall call && HasMarker(call.Program, visited))
-                    return true;
-            return false;
-        }
-
-        public static bool HasTail(Program program) => IndexOf(program) >= 0;
-
-        /// <summary>
-        /// Appends the outline after the marker: a rapid to its start, then its entities on the
-        /// display perimeter layer. <paramref name="program"/> must still be in absolute mode.
-        /// </summary>
-        internal static void Append(Program program, IReadOnlyList<ICode> outline, Vector start)
-        {
-            if (program.Mode != Mode.Absolute)
-                throw new InvalidOperationException("Append the display tail before switching to incremental mode.");
-            program.Codes.Add(new Comment(Marker));
-            program.Codes.Add(new RapidMove(start));
-            program.Codes.AddRange(outline);
-        }
-
-        /// <summary>
-        /// The executed program for estimates and drawing: <paramref name="program"/> itself when it
-        /// has no well-formed tail, otherwise a shallow copy of the codes before the marker. Posts
-        /// and verification use the strict <see cref="ForPosting"/> and executed reads instead.
-        /// </summary>
-        public static Program WithoutTail(Program program)
-        {
-            try
-            {
-                var marker = IndexOf(program);
-                return marker < 0 ? program : program.HeadCopy(marker);
-            }
-            catch (ArgumentException)
-            {
-                return program;
-            }
-        }
-
-        /// <summary>Whether <paramref name="program"/> or any sub-program it calls moves on the display perimeter layer.</summary>
-        public static bool HasDisplayPerimeterMotion(Program program) =>
-            HasDisplayPerimeterMotion(program, new HashSet<Program>(ReferenceEqualityComparer.Instance));
-
-        private static bool HasDisplayPerimeterMotion(Program program, HashSet<Program> visited)
-        {
-            if (program?.Codes == null || !visited.Add(program))
-                return false;
-            foreach (var code in program.Codes)
-            {
-                if (code is LinearMove { Layer: LayerType.DisplayPerimeter } or ArcMove { Layer: LayerType.DisplayPerimeter })
-                    return true;
-                if (code is SubProgramCall call && HasDisplayPerimeterMotion(call.Program, visited))
-                    return true;
-            }
-            return false;
-        }
-
-        /// <summary>
-        /// The program a post may write for a part: its tail removed. A display perimeter anywhere
-        /// else means the part was never planned, and posting it would cut the blank's outline.
-        /// </summary>
-        public static Program ForPosting(Program program, string partName)
-        {
-            int marker;
-            try
-            {
-                marker = IndexOf(program);
-            }
-            catch (ArgumentException ex)
-            {
-                throw new InvalidOperationException($"{partName} cannot be posted: {ex.Message}", ex);
-            }
-            var executed = marker < 0 ? program : program.HeadCopy(marker);
-            if (HasDisplayPerimeterMotion(executed))
-                throw new InvalidOperationException(
-                    $"{partName} has a display perimeter (a supplied blank's outline that is never cut) but no "
-                    + "cutting plan. Plan cutting first (Plate > Plan Cutting..., or --plan-cutting) so only its cutouts are cut.");
-            return executed;
-        }
-
-        /// <summary>The name posts give a part in a refusal.</summary>
-        public static string PartName(Part part) => $"Part '{part.BaseDrawing?.Name}'";
-
-        /// <summary>
-        /// Refuses a nest a post cannot write, before any output is created: every part's program
-        /// must pass <see cref="ForPosting"/>, so a refusal never leaves an empty or partial file.
-        /// </summary>
-        public static void EnsurePostable(Nest nest)
-        {
-            ArgumentNullException.ThrowIfNull(nest);
-            foreach (var plate in nest.Plates)
-                foreach (var part in plate.Parts)
-                    if (part?.Program != null && part.BaseDrawing?.IsCutOff != true)
-                        ForPosting(part.Program, PartName(part));
-        }
-    }
-}

OpenNest.Core/CNC/HeadHeightLock.cs

@@ -1,84 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace OpenNest.CNC
-{
-    /// <summary>
-    /// The head-height lock around a cut-off's overcut past the nominal far sheet edge. Stock can
-    /// arrive wider than nominal, so a cut-off overcuts past the far edge to cut the oversize off;
-    /// past the real edge there is no material to sense, so the head height is locked first. A
-    /// cut-off program marks the locked stretch with a <see cref="Lock"/> comment and ends it with an
-    /// <see cref="Unlock"/> comment; a rapid between them keeps the head locked and is not a head
-    /// raise. Posts write each marker as their machine's lock or unlock code and refuse to post a
-    /// marked program when no code is configured, because the overcut is unsafe without the lock.
-    /// See docs/automatic-scrap-cutoffs.md.
-    /// </summary>
-    public static class HeadHeightLock
-    {
-        /// <summary>The comment before the first motion made with the head height locked.</summary>
-        public const string Lock = "HEAD HEIGHT LOCK";
-
-        /// <summary>The comment after the last motion made with the head height locked.</summary>
-        public const string Unlock = "HEAD HEIGHT UNLOCK";
-
-        public static bool IsLock(ICode code) => code is Comment { Value: Lock };
-
-        public static bool IsUnlock(ICode code) => code is Comment { Value: Unlock };
-
-        /// <summary>Whether <paramref name="program"/>'s own codes hold a lock marker.</summary>
-        public static bool IsMarked(Program program)
-        {
-            if (program?.Codes == null)
-                return false;
-            foreach (var code in program.Codes)
-                if (IsLock(code))
-                    return true;
-            return false;
-        }
-
-        /// <summary>
-        /// For each of <paramref name="codes"/>, whether the head height is locked while it runs: the
-        /// codes after a lock marker up to its unlock marker. Markers must alternate, starting with a
-        /// lock and ending unlocked; anything else is a malformed program (<see cref="ArgumentException"/>),
-        /// since a post that lost track of the lock could cut off the sheet unlocked or never unlock.
-        /// </summary>
-        public static bool[] LockedMask(IReadOnlyList<ICode> codes)
-        {
-            ArgumentNullException.ThrowIfNull(codes);
-            var mask = new bool[codes.Count];
-            var locked = false;
-            for (var i = 0; i < codes.Count; i++)
-            {
-                if (IsLock(codes[i]))
-                {
-                    if (locked)
-                        throw new ArgumentException("A head-height lock is set twice without an unlock.");
-                    locked = true;
-                }
-                else if (IsUnlock(codes[i]))
-                {
-                    if (!locked)
-                        throw new ArgumentException("A head-height unlock has no lock before it.");
-                    locked = false;
-                }
-                else
-                    mask[i] = locked;
-            }
-            if (locked)
-                throw new ArgumentException("A head-height lock is never released.");
-            return mask;
-        }
-
-        /// <summary>
-        /// 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) =>
-            PostMarkers.EnsurePostable(nest, hasCodes, IsMarked, program => LockedMask(program.Codes),
-                name => $"{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 "
-                    + $"\"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 "
-                    + "with \"Lock head height and overcut the far edge\" unchecked.");
-    }
-}

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

@@ -21,22 +21,5 @@ namespace OpenNest.CNC
         /// leaves it out, cutting the rest of the contour as open pieces.
         /// </summary>
         Tab,
-
-        /// <summary>
-        /// The outside edge of a supplied blank that is only shown, never cut (for example a
-        /// purchased door whose instrument cutouts are the only cuts). It bounds material like
-        /// <see cref="Cut"/>, so nesting, containment, lead clearance and cut-offs all see the
-        /// blank, but it has no pierce, lead or motion in any emitted program. It must be one whole
-        /// 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/Program.cs

@@ -158,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)
         {
@@ -480,21 +508,6 @@ namespace OpenNest.CNC
             return true;
         }
 
-        /// <summary>
-        /// A shallow copy holding only the first <paramref name="count"/> codes: the same
-        /// instruction, variable and sub-program instances, mode and rotation.
-        /// </summary>
-        internal Program HeadCopy(int count)
-        {
-            var head = new Program() { mode = this.mode, Rotation = this.Rotation };
-            head.Codes.AddRange(Codes.GetRange(0, count));
-            foreach (var kvp in Variables)
-                head.Variables[kvp.Key] = kvp.Value;
-            foreach (var kvp in SubPrograms)
-                head.SubPrograms[kvp.Key] = kvp.Value;
-            return head;
-        }
-
         public object Clone()
         {
             var pgm = new Program() { mode = this.mode, Rotation = this.Rotation };

OpenNest.Core/CNC/RapidEnumerator.cs

@@ -31,8 +31,6 @@ namespace OpenNest.CNC
 
         private static Vector AppendProgram(Program pgm, Vector basePos, Vector startPos, List<Segment> results)
         {
-            // The head never travels to a display perimeter's tail.
-            pgm = DisplayPerimeterTail.WithoutTail(pgm);
             // Draw the approach to the first rapid destination, or to the program
             // origin when it starts cutting without a rapid. Only an initial rapid
             // (or call arrival) is already represented by this approach; a later

OpenNest.Core/ClampRail.cs

@@ -26,16 +26,14 @@ namespace OpenNest
             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
             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
                     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
             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
         /// </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
         /// <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
             && 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/CommonLineCutting.cs

@@ -1,197 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.CNC;
-using OpenNest.Geometry;
-
-namespace OpenNest
-{
-    /// <summary>
-    /// One shared cut of a common-line group, cut once on the centerline by <see cref="Owner"/>, the
-    /// member of the pair cut first. <see cref="Partner"/> is cut later; its remainder ends in the
-    /// kerf this cut opened.
-    /// </summary>
-    public sealed record CommonLineSharedCut(CommonLineSpan Span, 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>Every span <paramref name="member"/> shares, whoever cuts it.</summary>
-        public IEnumerable<CommonLineSpan> SpansOf(Part member) => Cuts
-            .Where(cut => ReferenceEquals(cut.Owner, member) || ReferenceEquals(cut.Partner, member))
-            .Select(cut => cut.Span);
-    }
-
-    /// <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 = check.Spans
-                .Select(span => Rank(span.First) < Rank(span.Second)
-                    ? new CommonLineSharedCut(span, span.First, span.Second)
-                    : new CommonLineSharedCut(span, span.Second, span.First))
-                .OrderBy(cut => Rank(cut.Owner))
-                .ToList();
-            return new CommonLineCutOrder(group, order, cuts);
-        }
-
-        /// <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 <paramref name="spans"/> and whose shared portions are on the
-        /// <see cref="LayerType.Tab"/> layer: material that this member never cuts, because the
-        /// shared cut does. The result is absolute. Only straight top-level moves can share.
-        /// </summary>
-        /// <exception cref="ArgumentException">A span does not lie along the program's edges.</exception>
-        public static Program MarkSharedSpans(Program clean, Vector location, IReadOnlyList<CommonLineSpan> spans,
-            double kerf)
-        {
-            ArgumentNullException.ThrowIfNull(clean);
-            ArgumentNullException.ThrowIfNull(spans);
-            if (!double.IsFinite(kerf) || kerf <= 0)
-                throw new ArgumentOutOfRangeException(nameof(kerf));
-            var program = (Program)clean.Clone();
-            program.Mode = Mode.Absolute;
-            var local = spans.Select(span => (Start: span.Start - location, End: span.End - location)).ToArray();
-            var covered = new double[local.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, local, covered, kerf));
-                    position = line.EndPoint;
-                    continue;
-                }
-                codes.Add(code);
-                position = code switch
-                {
-                    Motion motion => motion.EndPoint,
-                    SubProgramCall => null,
-                    _ => position,
-                };
-            }
-            for (var i = 0; i < local.Length; i++)
-                if (System.Math.Abs(covered[i] - local[i].Start.DistanceTo(local[i].End)) > CommonLineGeometry.GapTolerance)
-                    throw new ArgumentException(FormattableString.Invariant(
-                        $"The shared span from ({spans[i].Start.X:0.####}, {spans[i].Start.Y:0.####}) to ({spans[i].End.X:0.####}, {spans[i].End.Y:0.####}) does not lie along one straight edge of the part's program."));
-            program.Codes.Clear();
-            program.Codes.AddRange(codes);
-            return program;
-        }
-
-        // The line split where shared spans one half kerf off it begin and end; shared pieces on Tab.
-        private static IEnumerable<ICode> Split(LinearMove line, Vector start, (Vector Start, Vector End)[] spans,
-            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 < spans.Length; i++)
-            {
-                var (a, b) = spans[i];
-                var spanLength = a.DistanceTo(b);
-                if (spanLength <= Math.Tolerance.Epsilon)
-                    continue;
-                var along = new Vector((b.X - a.X) / spanLength, (b.Y - a.Y) / spanLength);
-                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 = Dot(a - start, direction);
-                var tb = Dot(b - start, direction);
-                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);
-        }
-
-        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/CommonLineGeometry.cs

@@ -1,237 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.CNC;
-using OpenNest.Diagnostics;
-using OpenNest.Geometry;
-
-namespace OpenNest
-{
-    /// <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>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 best = FacingEdges(Edges(anchor, cache), Edges(moving, cache), -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;
-            return new Vector(chosen.First.Outward.X * shift, chosen.First.Outward.Y * shift);
-        }
-
-        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/CommonLineGroup.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace OpenNest
-{
-    /// <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/CommonLineJoiner.cs

@@ -1,88 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Geometry;
-
-namespace OpenNest
-{
-    /// <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/CommonLineUsage.cs

@@ -1,47 +0,0 @@
-namespace OpenNest
-{
-    /// <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
-{
-    /// <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

@@ -183,12 +183,6 @@ namespace OpenNest.Converters
             if (string.Equals(name, SpecialLayers.Tab.Name, System.StringComparison.OrdinalIgnoreCase))
                 return LayerType.Tab;
 
-            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

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

OpenNest.Core/CutOff.cs

@@ -11,13 +11,9 @@ namespace OpenNest
         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,83 +21,6 @@ namespace OpenNest
         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
-        /// arrive wider than nominal, so only the origin-side edge is certain: the overcut cuts the
-        /// oversize off. It replaces <see cref="CutOffSettings.Overtravel"/> at the far edge and
-        /// applies only when the line runs to that edge (no limit on that side).
-        /// </summary>
-        public double HeadLockOvercut { get; set; }
-
-        /// <summary>
-        /// Whether the segment reaching the far edge is cut from it toward the origin: it starts at
-        /// the nominal far edge, overcuts outward with the head locked, rapids back with the head
-        /// still locked, unlocks and cuts toward the origin. Ignored without a head-locked overcut,
-        /// since nothing else may start a cut at an edge whose position is unknown.
-        /// </summary>
-        public bool FarEdgeFirst { get; set; }
-
         public CutOff(Vector position, CutOffAxis axis)
         {
             Position = position;
@@ -116,150 +35,10 @@ namespace OpenNest
         )
         {
             var segments = ComputeSegments(plate, settings, cache);
-            var program = BuildProgram(segments, settings, LockedFarEdge(plate));
+            var program = BuildProgram(segments, settings);
             Drawing.Program = program;
         }
 
-        /// <summary>
-        /// The regenerated program split into its cutting segments, one rapid-and-cut program
-        /// each in program order, so the plate can sequence every segment on its own. A rapid with
-        /// the head height locked returns along the overcut and stays in its segment.
-        /// </summary>
-        public IReadOnlyList<Program> SegmentPrograms()
-        {
-            var program = Drawing.Program;
-            var result = new List<Program>();
-            if (program == null)
-                return result;
-            Program current = null;
-            var locked = false;
-            foreach (var code in program.Codes)
-            {
-                if (code is RapidMove && !locked || current == null)
-                {
-                    current = new Program(program.Mode);
-                    result.Add(current);
-                }
-                if (HeadHeightLock.IsLock(code))
-                    locked = true;
-                else if (HeadHeightLock.IsUnlock(code))
-                    locked = false;
-                current.Codes.Add(code);
-            }
-            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.
-        /// </summary>
-        internal static bool FarEdgeIsHigh(CutOffAxis axis, int quadrant) =>
-            axis == CutOffAxis.Vertical ? quadrant is 1 or 2 : quadrant is 1 or 4;
-
-        /// <summary>
-        /// The nominal far edge this cut-off overcuts with the head locked, along its axis, or null
-        /// when it has no head-locked overcut or a limit stops it short of that edge.
-        /// </summary>
-        private (double Edge, bool High)? LockedFarEdge(Plate plate)
-        {
-            if (!(HeadLockOvercut > 0) || !double.IsFinite(HeadLockOvercut))
-                return null;
-            var bounds = plate.BoundingBox(includeParts: false);
-            var high = FarEdgeIsHigh(Axis, plate.Quadrant);
-            if ((high ? EndLimit : StartLimit) != null)
-                return null;
-            var vertical = Axis == CutOffAxis.Vertical;
-            return (high ? (vertical ? bounds.Top : bounds.Right) : (vertical ? bounds.Bottom : bounds.Left), high);
-        }
-
-        /// <summary>
-        /// The same segment cut the other way at the far edge: a head-locked segment cut toward the
-        /// far edge becomes one started there, and back; null when <paramref name="segment"/> is not
-        /// one of the two forms <see cref="Regenerate"/> builds for the segment reaching that edge.
-        /// </summary>
-        public static Program ReverseAtFarEdge(Program segment)
-        {
-            if (segment?.Codes == null || segment.Mode != Mode.Absolute)
-                return null;
-            var codes = segment.Codes;
-            var result = new Program(segment.Mode);
-            // Toward the far edge: rapid near, cut to the edge, lock, overcut, unlock.
-            if (codes.Count == 5 && codes[0] is RapidMove { Suppressed: false } near
-                && codes[1] is LinearMove { Suppressed: false, Layer: LayerType.Cut } toEdge
-                && HeadHeightLock.IsLock(codes[2])
-                && codes[3] is LinearMove { Suppressed: false, Layer: LayerType.Cut } overcut
-                && HeadHeightLock.IsUnlock(codes[4]))
-            {
-                result.Codes.Add(new RapidMove(toEdge.EndPoint));
-                result.Codes.Add(new Comment(HeadHeightLock.Lock));
-                result.Codes.Add(new LinearMove(overcut.EndPoint));
-                result.Codes.Add(new RapidMove(toEdge.EndPoint));
-                result.Codes.Add(new Comment(HeadHeightLock.Unlock));
-                result.Codes.Add(new LinearMove(near.EndPoint));
-                return result;
-            }
-            // From the far edge: rapid to the edge, lock, overcut, rapid back, unlock, cut away.
-            if (codes.Count == 6 && codes[0] is RapidMove { Suppressed: false } edge
-                && HeadHeightLock.IsLock(codes[1])
-                && codes[2] is LinearMove { Suppressed: false, Layer: LayerType.Cut } outward
-                && codes[3] is RapidMove { Suppressed: false } back && back.EndPoint == edge.EndPoint
-                && HeadHeightLock.IsUnlock(codes[4])
-                && codes[5] is LinearMove { Suppressed: false, Layer: LayerType.Cut } away)
-            {
-                result.Codes.Add(new RapidMove(away.EndPoint));
-                result.Codes.Add(new LinearMove(edge.EndPoint));
-                result.Codes.Add(new Comment(HeadHeightLock.Lock));
-                result.Codes.Add(new LinearMove(outward.EndPoint));
-                result.Codes.Add(new Comment(HeadHeightLock.Unlock));
-                return result;
-            }
-            return null;
-        }
-
-        /// <summary>
-        /// Installs Plan Cutting's choice for the far-edge segment: <paramref name="segment"/> (one
-        /// of this cut-off's placed parts) takes <paramref name="program"/>, the same segment cut the
-        /// other way, and <see cref="FarEdgeFirst"/> and the whole-line program follow it, so
-        /// regeneration keeps the direction. The caller has checked that the program is that flip.
-        /// </summary>
-        internal void InstallFarEdgeSegment(Part segment, Program program)
-        {
-            var codes = new List<ICode>();
-            foreach (var part in SegmentPrograms())
-                codes.AddRange((ReverseAtFarEdge(part) != null ? program : part).Codes);
-            var whole = new Program(Drawing.Program?.Mode ?? Mode.Absolute);
-            whole.Codes.AddRange(codes);
-            segment.ReplaceCutOffProgram(program);
-            FarEdgeFirst = StartsAtFarEdge(program);
-            Drawing.Program = whole;
-        }
-
-        /// <summary>Whether <paramref name="segment"/> is the far-edge segment cut from the far edge.</summary>
-        public static bool StartsAtFarEdge(Program segment) =>
-            segment?.Codes is { Count: 6 } codes && codes[0] is RapidMove && HeadHeightLock.IsLock(codes[1]);
-
         /// <summary>Measures the same trimmed, filtered segments as regeneration without building a program.</summary>
         internal (double Length, int SegmentCount) MeasureSegments(
             Plate plate,
@@ -275,106 +54,38 @@ namespace OpenNest
         /// 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;
             var cutting = false;
-            var locked = false;
             foreach (var code in part.Program.Codes)
             {
-                if (HeadHeightLock.IsLock(code))
-                    locked = true;
-                else if (HeadHeightLock.IsUnlock(code))
-                    locked = false;
                 switch (code)
                 {
                     case RapidMove rapid:
-                        // A second pierce leaves an uncut gap; a head-locked rapid returns along
+                        if (cutting)
-                        // the overcut to where the cut toward the origin begins.
+                            return false; // A second pierce leaves an uncut gap.
-                        if (cutting && !locked)
-                            return null;
                         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 +95,10 @@ namespace OpenNest
                         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;
@@ -408,9 +119,6 @@ namespace OpenNest
         )
         {
             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 is { High: true } ? 0 : settings.Overtravel;
 
             double lineStart,
                 lineEnd,
@@ -420,22 +128,15 @@ namespace OpenNest
             {
                 cutPosition = Position.X;
                 lineStart = StartLimit ?? bounds.Y;
-                lineEnd = EndLimit ?? (bounds.Y + bounds.Width + overtravel);
+                lineEnd = EndLimit ?? (bounds.Y + bounds.Width + settings.Overtravel);
             }
             else
             {
                 cutPosition = Position.Y;
                 lineStart = StartLimit ?? bounds.X;
-                lineEnd = EndLimit ?? (bounds.X + bounds.Length + overtravel);
+                lineEnd = EndLimit ?? (bounds.X + bounds.Length + settings.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 +169,6 @@ namespace OpenNest
                 );
                 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 +181,27 @@ namespace OpenNest
             }
 
             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(
@@ -781,8 +436,7 @@ namespace OpenNest
 
         private Program BuildProgram(
             List<(double Start, double End)> segments,
-            CutOffSettings settings,
+            CutOffSettings settings
-            (double Edge, bool High)? farEdge
         )
         {
             var program = new Program();
@@ -799,22 +453,6 @@ namespace OpenNest
 
             foreach (var seg in segments)
             {
-                if (farEdge is var (edge, high) && (high ? seg.End : seg.Start) == edge)
-                {
-                    // The segment reaching the far edge overcuts it with the head height locked,
-                    // whichever way the rest of the line runs.
-                    var near = MakePoint(cutPos, high ? seg.Start : seg.End);
-                    var atEdge = MakePoint(cutPos, edge);
-                    var beyond = MakePoint(cutPos, high ? edge + HeadLockOvercut : edge - HeadLockOvercut);
-                    var towardEdge = new Program();
-                    towardEdge.Codes.Add(new RapidMove(near));
-                    towardEdge.Codes.Add(new LinearMove(atEdge));
-                    towardEdge.Codes.Add(new Comment(HeadHeightLock.Lock));
-                    towardEdge.Codes.Add(new LinearMove(beyond));
-                    towardEdge.Codes.Add(new Comment(HeadHeightLock.Unlock));
-                    program.Codes.AddRange((FarEdgeFirst ? ReverseAtFarEdge(towardEdge) : towardEdge).Codes);
-                    continue;
-                }
                 var (from, to) = toward ? (seg.End, seg.Start) : (seg.Start, seg.End);
                 program.Codes.Add(new RapidMove(MakePoint(cutPos, from)));
                 program.Codes.Add(new LinearMove(MakePoint(cutPos, to)));

OpenNest.Core/CutOffSegments.cs

@@ -1,106 +0,0 @@
-using System.Collections.Generic;
-using OpenNest.CNC;
-using OpenNest.Geometry;
-
-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
-    /// nominal line passes through lie in the gaps between segments, so each is inside the span
-    /// of the segment on either side of it; a segment is cut before exactly those parts.
-    /// </summary>
-    public sealed record CutOffSegment(Part Part, double Start, double End, double SpanStart, double SpanEnd);
-
-    /// <summary>
-    /// A cut-off's trimmed segments are materialized as one part each, so every segment has its
-    /// own place in the cut sequence. This finds those parts and the span each stands for.
-    /// </summary>
-    public static class CutOffSegments
-    {
-        /// <summary>The definition's placed segment parts in ascending order along its axis.</summary>
-        public static IReadOnlyList<CutOffSegment> Of(Plate plate, CutOff definition) =>
-            Of(definition, plate.Parts, plate.BoundingBox(includeParts: false));
-
-        /// <summary>
-        /// The definition's segment parts among <paramref name="parts"/> (those placed from its
-        /// drawing) in ascending order along its axis, with spans measured against the nominal
-        /// line's limits on <paramref name="sheet"/>. A part whose cut cannot be measured stands
-        /// for the whole line.
-        /// </summary>
-        public static IReadOnlyList<CutOffSegment> Of(CutOff definition, IEnumerable<Part> parts, Box sheet)
-        {
-            var vertical = definition.Axis == CutOffAxis.Vertical;
-            var lineStart = definition.StartLimit ?? (vertical ? sheet.Bottom : sheet.Left);
-            var lineEnd = definition.EndLimit ?? (vertical ? sheet.Top : sheet.Right);
-            var low = System.Math.Min(lineStart, lineEnd);
-            var high = System.Math.Max(lineStart, lineEnd);
-            var measured = new List<(Part Part, double Start, double End)>();
-            var whole = new List<CutOffSegment>();
-            foreach (var part in parts)
-            {
-                if (!ReferenceEquals(part.BaseDrawing, definition.Drawing))
-                    continue;
-                if (Extent(part, vertical) is { } extent)
-                    measured.Add((part, extent.Start, extent.End));
-                else
-                    whole.Add(new CutOffSegment(part, low, high, low, high));
-            }
-            measured.Sort((a, b) => a.Start != b.Start ? a.Start.CompareTo(b.Start) : a.End.CompareTo(b.End));
-            var result = new List<CutOffSegment>(measured.Count + whole.Count);
-            for (var i = 0; i < measured.Count; i++)
-            {
-                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);
-            return result;
-        }
-
-        /// <summary>
-        /// The extent along the cut-off's axis of the part's cutting moves, or null when the
-        /// part cuts nothing or its program is not the absolute rapid-and-cut form cut-offs use.
-        /// </summary>
-        public static (double Start, double End)? Extent(Part part, bool vertical)
-        {
-            if (part?.Program == null || part.Program.Mode != Mode.Absolute)
-                return null;
-            double? min = null, max = null;
-            Vector? position = null;
-            foreach (var code in part.Program.Codes)
-            {
-                switch (code)
-                {
-                    case RapidMove rapid:
-                        position = rapid.EndPoint + part.Location;
-                        break;
-                    case Motion motion when position != null:
-                        var end = motion.EndPoint + part.Location;
-                        foreach (var point in new[] { position.Value, end })
-                        {
-                            var along = vertical ? point.Y : point.X;
-                            min = min == null ? along : System.Math.Min(min.Value, along);
-                            max = max == null ? along : System.Math.Max(max.Value, along);
-                        }
-                        position = end;
-                        break;
-                    case Motion:
-                        return null;
-                }
-            }
-            return min == null ? null : (min.Value, max.Value);
-        }
-    }
-}

OpenNest.Core/CutOffSettings.cs

@@ -12,20 +12,5 @@ namespace OpenNest
         public double Overtravel { get; set; }
         public double MinSegmentLength { get; set; } = 0.05;
         public CutDirection CutDirection { get; set; } = CutDirection.AwayFromOrigin;
-
-        /// <summary>
-        /// Whether new cut-offs lock the head height and overcut past the nominal far sheet edge
-        /// by <see cref="HeadLockOvercut"/> (see <see cref="CutOff.HeadLockOvercut"/>). Off until
-        /// the machine's post has head-height lock codes.
-        /// </summary>
-        public bool LockHeadHeight { get; set; }
-
-        /// <summary>How far past the nominal far edge a head-locked cut-off cuts, in model units.</summary>
-        public double HeadLockOvercut { get; set; } = 1.5;
-
-        /// <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/CutOffTrim.cs

@@ -1,500 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest
-{
-    /// <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

@@ -28,26 +28,15 @@ public static class ClampCutDiagnostics
             var cut = plate.CutOffs[index];
             if (cut == null || !Enum.IsDefined(cut.Axis))
                 throw new ArgumentException("Cut-off has an invalid axis.", nameof(plate));
-            // A head-locked overcut runs on past the far edge, where an off-sheet clamp can be.
+            var start = cut.Axis == CutOffAxis.Vertical
-            var overcut = cut.HeadLockOvercut > 0 && double.IsFinite(cut.HeadLockOvercut) ? cut.HeadLockOvercut : 0;
+                ? new Vector(cut.Position.X, cut.StartLimit ?? sheet.Bottom)
-            var farHigh = CutOff.FarEdgeIsHigh(cut.Axis, plate.Quadrant);
+                : new Vector(cut.StartLimit ?? sheet.Left, cut.Position.Y);
-            var low = farHigh ? 0 : overcut;
+            var end = cut.Axis == CutOffAxis.Vertical
-            var high = farHigh ? overcut : 0;
+                ? new Vector(cut.Position.X, cut.EndLimit ?? sheet.Top)
-            var vertical = cut.Axis == CutOffAxis.Vertical;
+                : new Vector(cut.EndLimit ?? sheet.Right, cut.Position.Y);
-            var from = cut.StartLimit ?? (vertical ? sheet.Bottom : sheet.Left) - low;
-            var to = cut.EndLimit ?? (vertical ? sheet.Top : sheet.Right) + high;
-            // A clamp wholly inside a gap meets no cut.
             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,188 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using OpenNest.CNC;
-using OpenNest.CNC.CuttingPlanning;
-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,
-/// on its centerline, by the member cut first; one set to cut them twice must have no shared cuts.
-/// 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)>();
-        foreach (var member in group.Members)
-        {
-            token.ThrowIfCancellationRequested();
-            try
-            {
-                cuts.AddRange(ExecutionMotionReader.Read(member.Program, member.Location, null, token).Motions
-                    .Where(motion => !motion.Rapid && motion.Layer == LayerType.CommonLine && motion.Curve != null)
-                    .Select(motion => (member, motion)));
-            }
-            catch (Exception exception) when (IsInvalid(exception))
-            {
-                // The rapid check reports the unreadable program.
-            }
-        }
-        if (plate.CutCommonLinesTwice)
-        {
-            if (cuts.Count > 0)
-                findings.Add(new(PostVerificationKind.CommonLine, plateNumber, Number(plate, cuts[0].Part), 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 = cuts[0].Motion.Curve.Midpoint });
-            return;
-        }
-        foreach (var span in check.Spans)
-        {
-            token.ThrowIfCancellationRequested();
-            var covering = cuts.Where(cut => Covers(cut.Motion, span)).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 once on its centerline. 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. Plan cutting again before posting.")
-                { Location = middle });
-            // 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 shared cut on the span's centerline that covers the whole span.
-    private static bool Covers(ExecutionMotion motion, CommonLineSpan span)
-    {
-        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) => System.Math.Abs((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;
-        if (Offset(curve.Start) > tolerance || Offset(curve.End) > 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,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using OpenNest.CNC;
 
 namespace OpenNest.Diagnostics;
@@ -14,26 +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)[] 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;
 
     private OverlapGeometryStamp(Plate plate)
     {
         this.plate = plate;
         sheet = SheetState(plate);
-        partSpacing = Bits(plate.PartSpacing);
-        commonLines = CommonLineState(plate);
         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?)[plate.CutOffs.Count];
         for (var i = 0; i < cutoffs.Length; i++)
             cutoffs[i] = CutOffState(plate.CutOffs[i]);
     }
@@ -44,12 +36,11 @@ 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?) 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.EndLimit.HasValue ? Bits(cut.EndLimit.Value) : null);
-                cut.Gaps, Bits(cut.HeadLockOvercut));
 
     private static long Bits(double value) => BitConverter.DoubleToInt64Bits(value);
 
@@ -82,19 +73,9 @@ public sealed class OverlapGeometryStamp
         return true;
     }
 
-    internal bool SameSpacing(Plate current) =>
-        ReferenceEquals(plate, current) && partSpacing == Bits(current.PartSpacing)
-        && commonLines == CommonLineState(current);
-
-    // 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) || !SameZones(current) || !SameCutOffs(current))
             return false;
         for (var i = 0; i < entries.Length; i++)
             if (!entries[i].Matches(current.Parts[i]))

OpenNest.Core/Diagnostics/OverlapMarker.cs

@@ -48,13 +48,13 @@ internal static class OverlapMarker
         point = default;
         var minY = outline.Min(vertex => vertex.Y);
         var maxY = outline.Max(vertex => vertex.Y);
-        var center = (minY + maxY) / 2;
+        var centre = (minY + maxY) / 2;
         double below = minY, above = maxY;
         foreach (var vertex in outline.Concat(holes.SelectMany(hole => hole)))
         {
-            if (vertex.Y <= center && vertex.Y > below)
+            if (vertex.Y <= centre && vertex.Y > below)
                 below = vertex.Y;
-            else if (vertex.Y > center && vertex.Y < above)
+            else if (vertex.Y > centre && vertex.Y < above)
                 above = vertex.Y;
         }
         var y = (below + above) / 2;

OpenNest.Core/Diagnostics/OverlapMaterial.cs

@@ -31,17 +31,11 @@ internal sealed record OverlapMaterial(Polygon Outer, List<Polygon> Holes)
         }
         // Sampling can hide a crossing or tangency between curves. Reject native
         // contour contact before asking the polygon approximation about containment.
-        // A contact lies within both entities' bounds, so shapes whose bounds are clear by more
-        // than any native query's allowance cannot touch: a part with thousands of holes does
-        // not query every pair.
-        var boxes = shapes.Select(shape => shape.BoundingBox).ToList();
         for (var i = 0; i < shapes.Count; i++)
         {
             cancellationToken.ThrowIfCancellationRequested();
             for (var j = 0; j < i; j++)
             {
-                if (ClearOfNativeQueries(boxes[i], boxes[j]))
-                    continue;
                 shapes[i].Intersects(shapes[j], out var intersections);
                 if (intersections.Count > 0)
                     throw new ArgumentException("Native material contours cross or touch.");
@@ -50,70 +44,23 @@ internal sealed record OverlapMaterial(Polygon Outer, List<Polygon> Holes)
         var ordered = polygons.OrderByDescending(polygon => Area(polygon.Vertices)).ToList();
         var outer = ordered[0];
         var holes = ordered.Skip(1).ToList();
-        var outerBounds = BoundsOf(outer);
-        var holeBounds = holes.Select(BoundsOf).ToList();
         for (var i = 0; i < holes.Count; i++)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            if (BoundariesTouch(outer, outerBounds, holes[i], holeBounds[i], cancellationToken)
+            if (BoundariesTouch(outer, holes[i], cancellationToken)
-                || !Inside(outer, outerBounds, holes[i].Vertices[0]))
+                || !Inside(outer, holes[i].Vertices[0]))
                 throw new ArgumentException("Contours must have one outer with strictly internal holes.");
             for (var j = 0; j < i; j++)
             {
-                // Exact polygon tests: holes whose vertex bounds are apart can neither touch
+                if (BoundariesTouch(holes[i], holes[j], cancellationToken)
-                // nor contain each other's vertices.
+                    || Inside(holes[i], holes[j].Vertices[0])
-                if (!Overlap(holeBounds[i], holeBounds[j]))
+                    || Inside(holes[j], holes[i].Vertices[0]))
-                    continue;
-                if (BoundariesTouch(holes[i], holeBounds[i], holes[j], holeBounds[j], cancellationToken)
-                    || Inside(holes[i], holeBounds[i], holes[j].Vertices[0])
-                    || Inside(holes[j], holeBounds[j], holes[i].Vertices[0]))
                     throw new ArgumentException("Intersecting holes and nested material islands are unsupported.");
             }
         }
         return new OverlapMaterial(outer, holes);
     }
 
-    /// <summary>
-    /// The gap beyond which no native intersection query counts two entities as touching: ten
-    /// times the 0.00001 bounding-box allowance of native intersections, as the planner's
-    /// <c>PostVerificationGeometry.Extent.ClearMargin</c>.
-    /// </summary>
-    private const double NativeClearMargin = 1e-3;
-
-    // True only when both boxes are finite and apart by more than the native allowance on some axis.
-    private static bool ClearOfNativeQueries(Box a, Box b) =>
-        IsFinite(a) && IsFinite(b)
-        && (a.Right + NativeClearMargin < b.Left || b.Right + NativeClearMargin < a.Left
-            || a.Top + NativeClearMargin < b.Bottom || b.Top + NativeClearMargin < a.Bottom);
-
-    private static bool IsFinite(Box box) => double.IsFinite(box.Left) && double.IsFinite(box.Right)
-        && double.IsFinite(box.Bottom) && double.IsFinite(box.Top);
-
-    /// <summary>Exact vertex bounds of a sampled polygon, for skipping segment and winding tests.</summary>
-    private readonly record struct Bounds(double MinX, double MinY, double MaxX, double MaxY)
-    {
-        internal bool Contains(Vector point) =>
-            point.X >= MinX && point.X <= MaxX && point.Y >= MinY && point.Y <= MaxY;
-    }
-
-    private static Bounds BoundsOf(Polygon polygon)
-    {
-        double minX = double.PositiveInfinity, minY = double.PositiveInfinity,
-            maxX = double.NegativeInfinity, maxY = double.NegativeInfinity;
-        foreach (var vertex in polygon.Vertices)
-        {
-            minX = System.Math.Min(minX, vertex.X);
-            minY = System.Math.Min(minY, vertex.Y);
-            maxX = System.Math.Max(maxX, vertex.X);
-            maxY = System.Math.Max(maxY, vertex.Y);
-        }
-        return new(minX, minY, maxX, maxY);
-    }
-
-    // Closed-interval overlap: two segments that touch share a point inside both bounds.
-    private static bool Overlap(Bounds a, Bounds b) =>
-        a.MaxX >= b.MinX && b.MaxX >= a.MinX && a.MaxY >= b.MinY && b.MaxY >= a.MinY;
-
     internal OverlapMaterial Transform(double rotation, Vector offset) =>
         new(TransformPolygon(Outer, rotation, offset),
             Holes.Select(hole => TransformPolygon(hole, rotation, offset)).ToList());
@@ -224,23 +171,13 @@ internal sealed record OverlapMaterial(Polygon Outer, List<Polygon> Holes)
             throw new ArgumentException("Material contour could not be completely triangulated.");
     }
 
-    // Exact: a segment of a whose bounds are clear of b's bounds touches no segment of b.
+    private static bool BoundariesTouch(Polygon a, Polygon b, CancellationToken cancellationToken)
-    private static bool BoundariesTouch(Polygon a, Bounds aBounds, Polygon b, Bounds bBounds,
-        CancellationToken cancellationToken)
     {
-        if (!Overlap(aBounds, bBounds))
-            return false;
         for (var i = 0; i + 1 < a.Vertices.Count; i++)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            var start = a.Vertices[i];
-            var end = a.Vertices[i + 1];
-            var segment = new Bounds(System.Math.Min(start.X, end.X), System.Math.Min(start.Y, end.Y),
-                System.Math.Max(start.X, end.X), System.Math.Max(start.Y, end.Y));
-            if (!Overlap(segment, bBounds))
-                continue;
             for (var j = 0; j + 1 < b.Vertices.Count; j++)
-                if (SegmentsTouch(start, end, b.Vertices[j], b.Vertices[j + 1]))
+                if (SegmentsTouch(a.Vertices[i], a.Vertices[i + 1], b.Vertices[j], b.Vertices[j + 1]))
                     return true;
         }
         return false;
@@ -263,10 +200,6 @@ internal sealed record OverlapMaterial(Polygon Outer, List<Polygon> Holes)
         && point.Y >= System.Math.Min(a.Y, b.Y) && point.Y <= System.Math.Max(a.Y, b.Y);
 
     // Boundary contact is rejected before this winding-number test is used for topology.
-    // A point outside the polygon's vertex bounds has winding zero.
-    private static bool Inside(Polygon polygon, Bounds bounds, Vector point) =>
-        bounds.Contains(point) && Inside(polygon, point);
-
     private static bool Inside(Polygon polygon, Vector point)
     {
         var winding = 0;

OpenNest.Core/Diagnostics/OverlapPairPresentation.cs

@@ -26,17 +26,6 @@ public static class OverlapPairPresentation
             + $"Marker: ({Number(pair.Marker.X, provider)}, {Number(pair.Marker.Y, provider)}) {units}";
     }
 
-    public static string Label(PlateSpacingPair pair, IFormatProvider provider = null) =>
-        $"{pair.PartAId + 1}/{pair.PartBId + 1} gap {Number(pair.Gap, provider)}";
-
-    public static string Details(PlateSpacingPair pair, Units capturedUnits, IFormatProvider provider = null)
-    {
-        var units = UnitsHelper.GetShortString(capturedUnits);
-        return $"Part spacing {pair.PartAId + 1}/{pair.PartBId + 1}: {pair.PartAName} / {pair.PartBName}\n"
-            + $"Gap ≈ {Number(pair.Gap, provider)} {units}\n"
-            + $"Marker: ({Number(pair.Marker.X, provider)}, {Number(pair.Marker.Y, provider)}) {units}";
-    }
-
     // Significant figures adapt to scale: a positive sliver must never read as zero.
     public static string Number(double value, IFormatProvider provider = null) =>
         value.ToString("G6", provider ?? CultureInfo.CurrentCulture);
@@ -50,21 +39,15 @@ public static class OverlapPairPresentation
     /// Coincident or nearby markers return every matching pair in stable ID order.
     /// </summary>
     public static IReadOnlyList<PlateOverlapPair> HitTest(IEnumerable<PlateOverlapPair> pairs,
-        Func<Vector, Vector> worldToScreen, Vector pointer, int deviceDpi) =>
+        Func<Vector, Vector> worldToScreen, Vector pointer, int deviceDpi)
-        pairs.Where(pair => Hits(worldToScreen(pair.Marker), pointer, deviceDpi))
-            .OrderBy(pair => pair.PartAId).ThenBy(pair => pair.PartBId).ToArray();
-
-    /// <inheritdoc cref="HitTest(IEnumerable{PlateOverlapPair}, Func{Vector, Vector}, Vector, int)"/>
-    public static IReadOnlyList<PlateSpacingPair> HitTest(IEnumerable<PlateSpacingPair> pairs,
-        Func<Vector, Vector> worldToScreen, Vector pointer, int deviceDpi) =>
-        pairs.Where(pair => Hits(worldToScreen(pair.Marker), pointer, deviceDpi))
-            .OrderBy(pair => pair.PartAId).ThenBy(pair => pair.PartBId).ToArray();
-
-    private static bool Hits(Vector center, Vector pointer, int deviceDpi)
     {
         var radius = HitRadius(deviceDpi);
-        var dx = pointer.X - center.X;
+        return pairs.Where(pair =>
-        var dy = pointer.Y - center.Y;
+        {
-        return dx * dx + dy * dy <= radius * radius;
+            var center = worldToScreen(pair.Marker);
+            var dx = pointer.X - center.X;
+            var dy = pointer.Y - center.Y;
+            return dx * dx + dy * dy <= radius * radius;
+        }).OrderBy(pair => pair.PartAId).ThenBy(pair => pair.PartBId).ToArray();
     }
 }

OpenNest.Core/Diagnostics/OverlapReportState.cs

@@ -23,31 +23,20 @@ public sealed class OverlapReportState
     public IReadOnlyList<PlateOverlapPair> DisplayPairs { get; private set; } = Array.Empty<PlateOverlapPair>();
     public IReadOnlyList<CutOffClampFinding> DisplayCutOffClampFindings { get; private set; } =
         Array.Empty<CutOffClampFinding>();
-    /// <summary>Known part-spacing pairs safe to draw, retained like <see cref="DisplayPairs"/>.</summary>
-    public IReadOnlyList<PlateSpacingPair> DisplaySpacingPairs { get; private set; } =
-        Array.Empty<PlateSpacingPair>();
     public bool IsRunning => Status == OverlapCheckStatus.Checking;
-    /// <summary>A current, fully checked report with no finding of any kind.</summary>
-    public bool IsAllClear => Status == OverlapCheckStatus.Current && Report.Pairs.Count == 0
-        && Report.ClampFindings.Count == 0 && Report.CutOffClampFindings.Count == 0
-        && Report.SpacingPairs.Count == 0;
-    /// <summary>
-    /// The last published result's message, kept through layout edits and rechecks so the canvas
-    /// stays quiet until the next result; never a claim about the current layout. Null when none.
-    /// </summary>
-    public string SettledMessage { get; private set; }
-    /// <summary>Whether that last published result was all clear.</summary>
-    public bool SettledClear { get; private set; }
 
     public string Message => Status switch
     {
         OverlapCheckStatus.Checking => "Checking overlaps…",
-        OverlapCheckStatus.Current => CurrentMessage(),
+        OverlapCheckStatus.Current => Report.ClampFindings.Count == 0 && Report.CutOffClampFindings.Count == 0
+            ? (Report.Pairs.Count == 0 ? "No material overlaps detected"
+                : $"Overlaps: {Report.Pairs.Count} pairs")
+            : $"Overlaps: {Report.Pairs.Count} pairs, {Report.ClampFindings.Count} clamps, "
+                + $"{Report.CutOffClampFindings.Count} cut-off/clamp contacts",
         OverlapCheckStatus.Incomplete => $"Overlap check incomplete: {Report.Pairs.Count} overlapping pairs; "
             + (Report.ClampFindings.Count == 0 ? "" : $"{Report.ClampFindings.Count} clamp findings; ")
             + (Report.CutOffClampFindings.Count == 0 ? ""
                 : $"{Report.CutOffClampFindings.Count} cut-off/clamp contacts; ")
-            + (Report.SpacingPairs.Count == 0 ? "" : $"{Report.SpacingPairs.Count} pairs under part spacing; ")
             + $"{uncheckedPartCount} parts could not be checked",
         OverlapCheckStatus.Failed => "Overlap check failed — run Check Overlaps again",
         OverlapCheckStatus.Canceled => "Overlap check canceled",
@@ -55,50 +44,6 @@ public sealed class OverlapReportState
         _ => "Overlaps: not checked"
     };
 
-    /// <summary>A few steady words for the status bar; <see cref="Message"/> has the detail.</summary>
-    public string Summary => Status switch
-    {
-        OverlapCheckStatus.Checking => "Layout: checking…",
-        OverlapCheckStatus.Current => IsAllClear ? "Layout: OK" : "Layout: " + Findings(),
-        OverlapCheckStatus.Incomplete => "Layout: check incomplete",
-        OverlapCheckStatus.Failed => "Layout: check failed",
-        OverlapCheckStatus.Canceled => "Layout: check canceled",
-        OverlapCheckStatus.Stale => "Layout: out of date",
-        _ => "Layout: not checked"
-    };
-
-    /// <summary>True when <see cref="Summary"/> reports findings or a check that did not finish.</summary>
-    public bool NeedsAttention => Status is OverlapCheckStatus.Incomplete or OverlapCheckStatus.Failed
-        || Status == OverlapCheckStatus.Current && !IsAllClear;
-
-    private string Findings()
-    {
-        var overlaps = Report.Pairs.Count + Report.ClampFindings.Count + Report.CutOffClampFindings.Count;
-        var spacing = Report.SpacingPairs.Count;
-        var words = new List<string>();
-        if (overlaps != 0)
-            words.Add(overlaps == 1 ? "1 overlap" : $"{overlaps} overlaps");
-        if (spacing != 0)
-            words.Add($"{spacing} too close");
-        return string.Join(", ", words);
-    }
-
-    // Only a fully checked report that required a gap may clear spacing as well as overlaps.
-    private string CurrentMessage()
-    {
-        var spacing = Report.SpacingPairs.Count == 0 ? ""
-            : $"; part spacing: {Report.SpacingPairs.Count} pairs too close";
-        if (Report.ClampFindings.Count != 0 || Report.CutOffClampFindings.Count != 0)
-            return $"Overlaps: {Report.Pairs.Count} pairs, {Report.ClampFindings.Count} clamps, "
-                + $"{Report.CutOffClampFindings.Count} cut-off/clamp contacts{spacing}";
-        if (Report.Pairs.Count != 0)
-            return $"Overlaps: {Report.Pairs.Count} pairs{spacing}";
-        if (spacing.Length != 0)
-            return "No material overlaps" + spacing;
-        return Report.SpacingChecked ? "No material overlaps or part spacing violations detected"
-            : "No material overlaps detected";
-    }
-
     /// <summary>
     /// Starts a request. A manual check from Off shows Areas; an automatic recheck keeps
     /// the user's display choice, including Off.
@@ -121,13 +66,10 @@ public sealed class OverlapReportState
         DisplayPairs = report.ClampFindings.Count == 0 ? report.Pairs
             : report.Pairs.Concat(report.ClampFindings).ToList().AsReadOnly();
         DisplayCutOffClampFindings = report.CutOffClampFindings;
-        DisplaySpacingPairs = report.SpacingPairs;
         displayStamp = stamp;
         observedDisplayStamp = stamp;
-        uncheckedPartCount = CountUncheckedParts(report.Issues.Concat(report.SpacingIssues));
+        uncheckedPartCount = CountUncheckedParts(report.Issues);
         Status = report.IsComplete ? OverlapCheckStatus.Current : OverlapCheckStatus.Incomplete;
-        SettledMessage = Message;
-        SettledClear = IsAllClear;
         return true;
     }
 
@@ -181,12 +123,7 @@ public sealed class OverlapReportState
             && (pair.PartBId < 0 ? sameZones : unchanged[pair.PartBId])).ToList();
         if (retained.Count != DisplayPairs.Count)
             DisplayPairs = retained.AsReadOnly();
-        var sameSpacing = displayStamp.SameSpacing(plate);
+        if (DisplayPairs.Count == 0 && DisplayCutOffClampFindings.Count == 0)
-        var retainedSpacing = DisplaySpacingPairs.Where(pair => sameSpacing
-            && unchanged[pair.PartAId] && unchanged[pair.PartBId]).ToList();
-        if (retainedSpacing.Count != DisplaySpacingPairs.Count)
-            DisplaySpacingPairs = retainedSpacing.AsReadOnly();
-        if (DisplayPairs.Count == 0 && DisplayCutOffClampFindings.Count == 0 && DisplaySpacingPairs.Count == 0)
             ClearDisplayPairs();
         else
             observedDisplayStamp = OverlapGeometryStamp.Capture(plate);
@@ -196,7 +133,6 @@ public sealed class OverlapReportState
     {
         DisplayPairs = Array.Empty<PlateOverlapPair>();
         DisplayCutOffClampFindings = Array.Empty<CutOffClampFinding>();
-        DisplaySpacingPairs = Array.Empty<PlateSpacingPair>();
         displayStamp = null;
         observedDisplayStamp = null;
     }
@@ -212,11 +148,7 @@ public sealed class OverlapReportState
     private void Clear(OverlapCheckStatus status, bool preserveDisplay = false)
     {
         if (!preserveDisplay)
-        {
             ClearDisplayPairs();
-            SettledMessage = null;
-            SettledClear = false;
-        }
         Generation++;
         Report = null;
         uncheckedPartCount = 0;

OpenNest.Core/Diagnostics/PartSpacingReview.cs

@@ -15,26 +15,19 @@ namespace OpenNest.Diagnostics;
 /// Nest's layout check finds them: each part's clean nesting material
 /// (<see cref="NestingMaterial.ForNesting"/>, leads excluded) outlined by <see cref="SpacingOutline"/>,
 /// the leftmost of a pair inflated by <see cref="SpacingOutline.InflationFor"/>. That outline
-/// circumscribes arcs by up to its chord tolerance, more than the slack, and interactive fills
+/// circumscribes arcs by up to its chord tolerance, more than the slack, and engines add a margin
-/// place native arcs exactly at the spacing. So each candidate is confirmed on
+/// for it; interactive fills place native arcs exactly at the spacing. So each candidate is
-/// <see cref="NativeContours"/>, as the layout check confirms it, and reported only when that gap
+/// confirmed on the native contours flattened at <see cref="FineTolerance"/> and reported only when
-/// is short of the spacing by more than the slack. Zero spacing enforces nothing, so contact stays
+/// that gap is short of the spacing by more than the slack. Zero spacing enforces nothing, so
-/// valid.
+/// contact stays valid.
 /// Pairs whose material already overlaps, and parts the overlap check could not read, are left to
-/// that check. Clamps are not spacing-checked here; <see cref="PlateEdgeReview"/> checks the sheet edge. The pre-post review and the
+/// that check. The sheet edge and clamps are not spacing-checked here.
-/// desktop overlap label share this scan, so they cannot disagree.
-/// Two members of one common-line group (<see cref="Plate.CommonLines"/>) are held to the group's
-/// kerf instead of the part spacing: they are placed one kerf apart on purpose.
 /// </summary>
 internal static class PartSpacingReview
 {
-    /// <summary>One part to scan: <see cref="Id"/> is its position in the overlap check's input.
+    /// <summary>Chord tolerance of the confirming measurement. Circumscribed on both sides, it
-    /// The profile loads inside the scan's error boundary; null means no material.</summary>
+    /// understates a gap by at most twice this, a tenth of <see cref="SpacingOutline.SpacingSlack"/>.</summary>
-    internal sealed record SpacingInput(int Id, Func<ShapeProfile> Profile, Vector Location);
+    internal const double FineTolerance = SpacingOutline.SpacingSlack / 20;
-
-    /// <summary>True when <paramref name="spacing"/> requires any gap at all.</summary>
-    internal static bool Enforces(double spacing) =>
-        double.IsFinite(spacing) && SpacingOutline.InflationFor(spacing) > Tolerance.Epsilon;
 
     internal static void Add(Plate plate, int plateNumber, IReadOnlyList<Part> parts,
         IReadOnlyList<int> partNumbers, PlateOverlapReport overlap, List<PostVerificationFinding> findings,
@@ -47,92 +40,39 @@ internal static class PartSpacingReview
                 $"Part spacing check: plate part spacing {spacing} is not a finite, non-negative value."));
             return;
         }
-        var profiles = new Dictionary<(Program, long), ShapeProfile>();
-        var inputs = parts.Select((part, id) => new SpacingInput(id, () => Profile(part, profiles), part.Location))
-            .ToList();
-        Scan(inputs, spacing, CommonLinePairs(plate, parts), overlap.Pairs, overlap.Issues,
-            (a, b, message) => findings.Add(new(PostVerificationKind.Incomplete, plateNumber, partNumbers[a],
-                b is { } other ? partNumbers[other] : null, "Part spacing check: " + message)),
-            (a, b, gap, marker) => findings.Add(new(PostVerificationKind.PartSpacing, plateNumber, partNumbers[a],
-                partNumbers[b],
-                CommonLineKerf(plate, parts[a], parts[b]) is { } kerf
-                    ? $"'{Name(parts[a])}' and '{Name(parts[b])}' are {gap:F4} apart, closer than the "
-                        + $"kerf ({kerf:F4}) of their common-line group."
-                    : $"'{Name(parts[a])}' and '{Name(parts[b])}' are {gap:F3} apart, closer than the "
-                        + $"plate's part spacing ({spacing:F3}).")
-            { Location = marker }),
-            cancellationToken);
-    }
-
-    /// <summary>
-    /// The desktop label's check: the same scan over a snapshot's owned material, so it runs on
-    /// the overlap worker and never reads a live part. Pairs and issues keep input ids.
-    /// </summary>
-    internal static void Add(PlateOverlapSnapshot snapshot, IReadOnlyList<PlateOverlapPair> overlaps,
-        IReadOnlyList<PlateOverlapIssue> overlapIssues, List<PlateSpacingPair> pairs,
-        List<PlateOverlapIssue> issues, CancellationToken cancellationToken)
-    {
-        var spacing = snapshot.PartSpacing;
-        if (!Enforces(spacing))
-            return;
-        var names = snapshot.Parts.ToDictionary(part => part.Id, part => part.Name);
-        var profiles = new Dictionary<(OverlapSource, long), ShapeProfile>();
-        var inputs = snapshot.Parts
-            .Select(part => new SpacingInput(part.Id, () => Profile(part, profiles), part.Location)).ToList();
-        Scan(inputs, spacing, snapshot.CommonLinePairs, overlaps, overlapIssues,
-            (a, b, message) => issues.Add(new PlateOverlapIssue(a, b, message)),
-            (a, b, gap, marker) => pairs.Add(new PlateSpacingPair(a, b, names[a], names[b], gap, marker)),
-            cancellationToken);
-    }
-
-    /// <summary>
-    /// Reports each pair by input id, lower id first. <paramref name="incomplete"/> receives a
-    /// part or pair that could not be read; <paramref name="tooClose"/> a confirmed gap and its marker.
-    /// </summary>
-    private static void Scan(IReadOnlyList<SpacingInput> parts, double spacing,
-        IReadOnlyDictionary<(int, int), double> commonLines, IEnumerable<PlateOverlapPair> overlaps, IEnumerable<PlateOverlapIssue> overlapIssues,
-        Action<int, int?, string> incomplete, Action<int, int, double, Vector> tooClose,
-        CancellationToken cancellationToken)
-    {
         var inflateBy = SpacingOutline.InflationFor(spacing);
         if (inflateBy <= Tolerance.Epsilon || parts.Count < 2)
             return;
 
-        var unreadable = overlapIssues.Where(issue => issue.PartBId == null)
+        var unreadable = overlap.Issues.Where(issue => issue.PartBId == null)
             .Select(issue => issue.PartAId).ToHashSet();
-        var overlapping = overlaps.Select(pair => Key(pair.PartAId, pair.PartBId)).ToHashSet();
+        var overlapping = overlap.Pairs.Select(pair => Key(pair.PartAId, pair.PartBId)).ToHashSet();
-        var outlines = new Dictionary<ShapeProfile, (SpacingOutline Raw, SpacingOutline Inflated)>();
+        var profiles = new Dictionary<(Program, long), ShapeProfile>();
         var shapes = new ShapeProfile[parts.Count];
-        var fine = new NativeContours[parts.Count];
+        var fine = new FineRings[parts.Count];
         var raw = new SpacingOutline[parts.Count];
         var inflated = new SpacingOutline[parts.Count];
         for (var i = 0; i < parts.Count; i++)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            if (unreadable.Contains(parts[i].Id))
+            if (unreadable.Contains(i))
                 continue;
             try
             {
-                var profile = parts[i].Profile();
+                var profile = Profile(parts[i], profiles);
                 if (profile == null)
                     continue;
                 shapes[i] = profile;
-                // Repeated parts share a profile, so each shape is offset once.
+                raw[i] = SpacingOutline.Build(profile, parts[i].Location, 0);
-                if (!outlines.TryGetValue(profile, out var outline))
+                inflated[i] = SpacingOutline.Build(profile, parts[i].Location, inflateBy);
-                {
+                if (raw[i] == null || inflated[i] == null)
-                    outline = (SpacingOutline.Build(profile, Vector.Zero, 0),
-                        SpacingOutline.Build(profile, Vector.Zero, inflateBy));
-                    outlines[profile] = outline;
-                }
-                if (outline.Raw == null || outline.Inflated == null)
                     throw new ArgumentException("Part material has no closed perimeter.");
-                raw[i] = outline.Raw.MovedTo(parts[i].Location);
-                inflated[i] = outline.Inflated.MovedTo(parts[i].Location);
             }
             catch (Exception exception) when (IsInvalid(exception))
             {
                 raw[i] = inflated[i] = null;
-                incomplete(parts[i].Id, null, exception.Message);
+                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, partNumbers[i], null,
+                    "Part spacing check: " + exception.Message));
             }
         }
 
@@ -152,35 +92,40 @@ internal static class PartSpacingReview
                 // Sorted by Left, so nothing further along can reach part i either.
                 if (other.Left > reach.Right + Tolerance.Epsilon)
                     break;
-                var (first, second) = Key(parts[i].Id, parts[j].Id);
+                if (!BoxesTouch(reach, other) || overlapping.Contains(Key(i, j))
-                if (!BoxesTouch(reach, other) || overlapping.Contains((first, second))
                     || !inflated[i].Overlaps(raw[j]))
                     continue;
                 double gap;
                 Vector marker;
                 try
                 {
-                    fine[i] ??= NativeContours.Of(shapes[i], parts[i].Location);
+                    fine[i] ??= FineRings.Of(shapes[i], parts[i].Location);
-                    fine[j] ??= NativeContours.Of(shapes[j], parts[j].Location);
+                    fine[j] ??= FineRings.Of(shapes[j], parts[j].Location);
-                    gap = fine[i].GapTo(fine[j], spacing, out marker);
+                    gap = Gap(fine[i], fine[j], spacing, out marker);
                 }
                 catch (Exception exception) when (IsInvalid(exception))
                 {
-                    incomplete(first, second, exception.Message);
+                    findings.Add(new(PostVerificationKind.Incomplete, plateNumber,
+                        System.Math.Min(partNumbers[i], partNumbers[j]),
+                        System.Math.Max(partNumbers[i], partNumbers[j]),
+                        "Part spacing check: " + exception.Message));
                     continue;
                 }
-                // Common-line partners are one kerf apart by design, never less.
+                if (!(gap < spacing - SpacingOutline.SpacingSlack))
-                var required = commonLines != null && commonLines.TryGetValue((first, second), out var kerf)
+                    continue;
-                    ? System.Math.Min(kerf, spacing) : spacing;
+                var (first, second) = partNumbers[i] < partNumbers[j] ? (i, j) : (j, i);
-                if (gap < required - SpacingOutline.SpacingSlack)
+                findings.Add(new(PostVerificationKind.PartSpacing, plateNumber, partNumbers[first],
-                    tooClose(first, second, gap, marker);
+                    partNumbers[second],
+                    $"'{Name(parts[first])}' and '{Name(parts[second])}' are {gap:F3} apart, closer than the "
+                    + $"plate's part spacing ({spacing:F3}).")
+                { Location = marker });
             }
         }
     }
 
     /// <summary>Clean drawing material, rotated to the part's pose; null when the part has none.
     /// Converted once per program and rotation.</summary>
-    internal static ShapeProfile Profile(Part part, Dictionary<(Program, long), ShapeProfile> profiles)
+    private static ShapeProfile Profile(Part part, Dictionary<(Program, long), ShapeProfile> profiles)
     {
         var program = part.BaseDrawing.Program;
         var rotation = part.Rotation - program.Rotation;
@@ -190,64 +135,87 @@ internal static class PartSpacingReview
         if (profiles.TryGetValue(key, out var cached))
             return cached;
         // Conversion creates fresh geometry, so rotating it never touches the live program.
-        var profile = Rotated(ConvertProgram.ToGeometry(SeamOvercut.Trimmed(program))
+        var entities = ConvertProgram.ToGeometry(SeamOvercut.Trimmed(program))
-            .Where(entity => entity.Layer != SpecialLayers.Leadin && entity.Layer != SpecialLayers.Leadout),
+            .Where(entity => entity.Layer != SpecialLayers.Leadin && entity.Layer != SpecialLayers.Leadout)
-            rotation);
+            .ForNesting();
-        profiles[key] = profile;
-        return profile;
-    }
-
-    /// <summary>A snapshot source's material at a part's pose, from clones: sources are shared.</summary>
-    private static ShapeProfile Profile(CapturedOverlapPart part,
-        Dictionary<(OverlapSource, long), ShapeProfile> profiles)
-    {
-        var key = (part.Source, BitConverter.DoubleToInt64Bits(part.Rotation));
-        if (profiles.TryGetValue(key, out var cached))
-            return cached;
-        var profile = Rotated(part.Source.Entities.Select(entity => entity.Clone()), part.Rotation);
-        profiles[key] = profile;
-        return profile;
-    }
-
-    private static ShapeProfile Rotated(IEnumerable<Entity> owned, double rotation)
-    {
-        var entities = owned.ForNesting();
         if (rotation != 0)
             foreach (var entity in entities)
                 entity.Rotate(rotation);
         var profile = entities.Count == 0 ? null : new ShapeProfile(entities);
         if (profile != null && profile.Perimeter == null)
             throw new ArgumentException("Part material has no closed perimeter.");
+        profiles[key] = profile;
         return profile;
     }
 
-    private static (int, int) Key(int a, int b) => a < b ? (a, b) : (b, a);
+    /// <summary>Closest boundary approach between two parts, including a part inside the other's
-
+    /// cutout; <paramref name="marker"/> is the middle of that gap. Only edges within
-    /// <summary>
+    /// <paramref name="reach"/> of the other part's bounds can be closer than it, so the rest are
-    /// Each pair of <paramref name="parts"/> (by position, lower first) in one common-line group of
+    /// skipped. Infinity when no edges are that near.</summary>
-    /// <paramref name="plate"/>, with the group's kerf.
+    private static double Gap(FineRings a, FineRings b, double reach, out Vector marker)
-    /// </summary>
-    internal static IReadOnlyDictionary<(int, int), double> CommonLinePairs(Plate plate, IReadOnlyList<Part> parts)
     {
-        var pairs = new Dictionary<(int, int), double>();
+        var best = double.PositiveInfinity;
-        if (plate?.CommonLines is not { Count: > 0 } groups)
+        var middle = a.Bounds.Center;
-            return pairs;
+        var perimeterA = Near(a.Perimeter, b.Bounds, reach);
-        var positions = new Dictionary<Part, int>(ReferenceEqualityComparer.Instance);
+        var perimeterB = Near(b.Perimeter, a.Bounds, reach);
-        for (var i = 0; i < parts.Count; i++)
+        Measure(perimeterA, perimeterB);
-            if (parts[i] != null)
+        foreach (var hole in a.Holes)
-                positions.TryAdd(parts[i], i);
+            Measure(Near(hole, b.Bounds, reach), perimeterB);
-        foreach (var group in groups)
+        foreach (var hole in b.Holes)
+            Measure(perimeterA, Near(hole, a.Bounds, reach));
+        marker = middle;
+        return best;
+
+        void Measure(List<Line> ringA, List<Line> ringB)
         {
-            var ids = group.Members.Where(positions.ContainsKey).Select(member => positions[member]).ToList();
+            if (ringA.Count == 0 || ringB.Count == 0)
-            for (var i = 0; i < ids.Count; i++)
+                return;
-                for (var j = i + 1; j < ids.Count; j++)
+            var distance = Clearance.ClosestPoints(ringA, ringB, out var onA, out var onB);
-                    pairs[Key(ids[i], ids[j])] = group.Kerf;
+            if (distance < best)
+            {
+                best = distance;
+                middle = (onA + onB) * 0.5;
+            }
         }
-        return pairs;
     }
 
-    private static double? CommonLineKerf(Plate plate, Part a, Part b) =>
+    private static List<Line> Near(List<Line> lines, Box other, double reach) =>
-        plate.CommonLineGroupOf(a) is { } group && group.Contains(b) ? group.Kerf : null;
+        lines.Where(line =>
+            System.Math.Min(line.StartPoint.X, line.EndPoint.X) <= other.Right + reach
+            && System.Math.Max(line.StartPoint.X, line.EndPoint.X) >= other.Left - reach
+            && System.Math.Min(line.StartPoint.Y, line.EndPoint.Y) <= other.Top + reach
+            && System.Math.Max(line.StartPoint.Y, line.EndPoint.Y) >= other.Bottom - reach).ToList();
+
+    /// <summary>A part's native contours in world space, flattened at <see cref="FineTolerance"/>.
+    /// Circumscribed, so the measured gap never exceeds the true one by more than rounding.</summary>
+    private sealed class FineRings
+    {
+        public List<Line> Perimeter { get; private init; }
+        public List<List<Line>> Holes { get; private init; }
+        public Box Bounds { get; private init; }
+
+        public static FineRings Of(ShapeProfile profile, Vector location)
+        {
+            var perimeter = World(profile.Perimeter, location, out var bounds);
+            return new FineRings
+            {
+                Perimeter = perimeter.ToLines(),
+                Holes = profile.Cutouts.Select(cutout => World(cutout, location, out _).ToLines()).ToList(),
+                Bounds = bounds,
+            };
+        }
+
+        private static Polygon World(Shape shape, Vector location, out Box bounds)
+        {
+            var polygon = ClipperBridge.Flatten(shape, FineTolerance, true);
+            polygon.Offset(location);
+            polygon.UpdateBounds();
+            bounds = polygon.BoundingBox;
+            return polygon;
+        }
+    }
+
+    private static (int, int) Key(int a, int b) => a < b ? (a, b) : (b, a);
 
     private static string Name(Part part) => part.BaseDrawing.Name;
 

OpenNest.Core/Diagnostics/PartSupportReview.cs

@@ -1,131 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using OpenNest.CNC;
-using OpenNest.CNC.CuttingPlanning;
-using OpenNest.Geometry;
-using OpenNest.Support;
-
-namespace OpenNest.Diagnostics;
-
-/// <summary>
-/// Pre-post review of part support (docs/support-tabs.md). Every part whose cutting parameters
-/// ask for support tabs and that needs one (<see cref="SupportTabSettings.Analyze"/>: its plate's
-/// support bed cannot hold it level or, by size, its width is in the size range) must be
-/// cut with a tab that keeps it level, however its program was made (planned, placed by hand or
-/// locked); by size any tab will do. The tab is the gap the outside cut leaves between its end and its start. Reports
-/// only; a part whose material or program cannot be read is reported as not checked.
-/// </summary>
-internal static class PartSupportReview
-{
-    internal static void Add(Plate plate, int plateNumber, List<PostVerificationFinding> findings,
-        CancellationToken token)
-    {
-        var bed = plate.SupportBed;
-        for (var index = 0; index < plate.Parts.Count; index++)
-        {
-            token.ThrowIfCancellationRequested();
-            var part = plate.Parts[index];
-            var parameters = part?.CuttingParameters ?? plate.CuttingParameters;
-            if (part?.BaseDrawing == null || part.BaseDrawing.IsCutOff || !SupportTabSettings.CanTab(parameters, bed))
-                continue;
-            var partNumber = index + 1;
-            try
-            {
-                var support = SupportTabSettings.Analyze(parameters, bed, plate.Quadrant, SupportMaterial.FromPart(part));
-                if (support == null)
-                    continue;
-                if (!support.IsComplete)
-                {
-                    findings.Add(new(PostVerificationKind.Incomplete, plateNumber, partNumber, null,
-                        "Support check: " + support.Reason));
-                    continue;
-                }
-                if (support.IsSupported)
-                    continue;
-                var tab = OutsideTab(ExecutionMotionReader.Read(part.Program, part.Location, null, token));
-                if (tab is { } point && support.IsSteadiedByTabAt(point))
-                    continue;
-                findings.Add(new(PostVerificationKind.PartSupport, plateNumber, partNumber, null,
-                    Message(support, tab))
-                { Location = support.CenterOfGravity });
-            }
-            catch (Exception exception) when (exception is ArgumentException or InvalidOperationException
-                or NotSupportedException or ArithmeticException)
-            {
-                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, partNumber, null,
-                    "Support check: " + exception.Message));
-            }
-        }
-    }
-
-    /// <summary>
-    /// The middle of the gap the outside cut leaves open, or null when it closes: the outside cut
-    /// is the chain of cutting motions with the largest extent.
-    /// </summary>
-    internal static Vector? OutsideTab(OwnedExecution execution)
-    {
-        Vector? start = null, end = null, bestStart = null, bestEnd = null;
-        var minX = double.PositiveInfinity; var minY = double.PositiveInfinity;
-        var maxX = double.NegativeInfinity; var maxY = double.NegativeInfinity;
-        var bestArea = -1.0;
-        foreach (var motion in execution.Motions.Append(null))
-        {
-            if (motion is { Rapid: false, Layer: LayerType.Cut or LayerType.Display })
-            {
-                start ??= motion.Start ?? motion.End;
-                end = motion.End;
-                foreach (var p in new[] { motion.Start ?? motion.End, motion.End, motion.Curve?.Midpoint ?? motion.End })
-                {
-                    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);
-                }
-                continue;
-            }
-            // Anything else ends a chain: a rapid, a lead, a scribe or a break cut.
-            if (start != null && (maxX - minX) * (maxY - minY) > bestArea)
-            {
-                bestArea = (maxX - minX) * (maxY - minY);
-                bestStart = start;
-                bestEnd = end;
-            }
-            start = end = null;
-            minX = minY = double.PositiveInfinity;
-            maxX = maxY = double.NegativeInfinity;
-        }
-        if (bestStart is not { } first || bestEnd is not { } last
-            || first.DistanceTo(last) <= PostVerificationGeometry.Epsilon)
-            return null;
-        return (first + last) * 0.5;
-    }
-
-    private static string Message(PartSupport support, Vector? tab)
-    {
-        // Without a bed, or for a part its tab alone holds, any tab steadies the part, so the only
-        // failure is no tab at all.
-        if (!support.HasBed || support.IsHeldByTab)
-            return (support.HasBed
-                    ? FormattableString.Invariant(
-                        $"The part is {support.Length:0.####} long, short enough for its tab alone to hold, ")
-                    : FormattableString.Invariant(
-                        $"The part is {support.Width:0.####} wide, in the width range tabbed by size, "))
-                + "and it has no tab; it may tip once cut free."
-                + (support.BestTabPoint is { } suggested
-                    ? FormattableString.Invariant($" Tab it near ({suggested.X:0.####}, {suggested.Y:0.####}).")
-                    : "");
-        var held = support.Margin == double.NegativeInfinity
-            ? "rests on no support contact"
-            : support.Margin < 0
-                ? FormattableString.Invariant($"has its center of gravity {-support.Margin:0.####} outside its support contacts")
-                : FormattableString.Invariant($"has its center of gravity only {support.Margin:0.####} inside its support contacts");
-        var tabText = tab is { } point
-            ? FormattableString.Invariant($"its tab at ({point.X:0.####}, {point.Y:0.####}) does not steady it")
-            : "it has no tab";
-        var best = support.BestTabPoint is { } bestPoint && support.TabCanSupport
-            ? FormattableString.Invariant($" A tab near ({bestPoint.X:0.####}, {bestPoint.Y:0.####}) would.")
-            : " No single tab can steady it.";
-        return FormattableString.Invariant($"The part {held} (needs {support.RequiredMargin:0.####}) and {tabText}; ")
-            + "it may tip once cut free." + best;
-    }
-}

OpenNest.Core/Diagnostics/PlateEdgeReview.cs

@@ -1,182 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using Clipper2Lib;
-using OpenNest.CNC;
-using OpenNest.CNC.CuttingPlanning;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.Diagnostics;
-
-/// <summary>
-/// Parts that leave the sheet or come closer to its edges than the plate's edge spacing.
-/// <para>
-/// <b>Off the plate</b>: any cutting, lead or scribe motion of the placed program (its native
-/// curve bounds) past the sheet's bounding box, or, on an outlined sheet, clean material outside
-/// the outline or over one of its obstacles. A pierce or cut off the sheet cuts nothing, or the
-/// table.
-/// </para>
-/// <para>
-/// <b>Edge spacing</b>: clean nesting material (leads excluded, as the part-spacing check reads it)
-/// outside the plate's work area, or, on an outlined sheet, closer than the largest edge spacing to
-/// the outline or an obstacle: Auto Nest's layout check judges bounds exactly this way, so a layout
-/// it accepted stays clear. Shortfalls up to <see cref="SpacingOutline.SpacingSlack"/> pass. Leads
-/// may run into the edge spacing; only off the sheet do they warn.
-/// </para>
-/// Cut-off parts are exempt: they run to the sheet edge by design.
-/// </summary>
-internal static class PlateEdgeReview
-{
-    private const double Slack = SpacingOutline.SpacingSlack;
-
-    internal static void Add(Plate plate, int plateNumber, List<PostVerificationFinding> findings,
-        CancellationToken cancellationToken)
-    {
-        if (plate.Parts.Count == 0)
-            return;
-        var size = plate.Size;
-        if (!(size.Length > 0) || !(size.Width > 0) || !double.IsFinite(size.Length) || !double.IsFinite(size.Width))
-        {
-            findings.Add(new(PostVerificationKind.Incomplete, plateNumber, null, null,
-                $"Plate edge check: plate size {size} is not a positive, finite size."));
-            return;
-        }
-        var edges = plate.EdgeSpacing;
-        if (!new[] { edges.Left, edges.Bottom, edges.Right, edges.Top }.All(e => double.IsFinite(e) && e >= 0))
-        {
-            findings.Add(new(PostVerificationKind.Incomplete, plateNumber, null, null,
-                "Plate edge check: plate edge spacing is not finite and non-negative on every side."));
-            return;
-        }
-        var sheet = plate.BoundingBox(includeParts: false);
-        var work = plate.WorkArea();
-        var outline = plate.Outline;
-        var origin = new Vector(sheet.X, sheet.Y);
-        var inset = System.Math.Max(System.Math.Max(edges.Left, edges.Right), System.Math.Max(edges.Top, edges.Bottom));
-        var profiles = new Dictionary<(Program, long), ShapeProfile>();
-
-        for (var index = 0; index < plate.Parts.Count; index++)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            var part = plate.Parts[index];
-            var partNumber = index + 1;
-            if (part?.BaseDrawing == null || part.BaseDrawing.IsCutOff)
-                continue;
-            try
-            {
-                if (PastSheet(part, sheet, cancellationToken) is { } past)
-                {
-                    findings.Add(new(PostVerificationKind.OffPlate, plateNumber, partNumber, null,
-                        $"'{part.BaseDrawing.Name}' runs {past.Distance:F3} past the plate's {past.Edge} edge.")
-                    { Location = past.Marker });
-                    continue;
-                }
-
-                var profile = PartSpacingReview.Profile(part, profiles);
-                if (profile == null)
-                    continue;
-                PathsD region = null;
-                if (outline != null)
-                {
-                    var material = SpacingOutline.Build(profile, part.Location, 0)
-                        ?? throw new ArgumentException("Part material has no closed perimeter.");
-                    region = new PathsD { ClipperBridge.ToPath(material.Perimeter, positive: true) };
-                    if (!outline.Holds(region, 0, origin, Slack))
-                    {
-                        findings.Add(new(PostVerificationKind.OffPlate, plateNumber, partNumber, null,
-                            $"'{part.BaseDrawing.Name}' lies outside the plate's outline or over one of its obstacles.")
-                        { Location = Center(profile, part.Location) });
-                        continue;
-                    }
-                }
-
-                var bounds = profile.Perimeter.BoundingBox.Translate(part.Location);
-                if (Shortest(bounds, sheet, work) is { } close)
-                {
-                    findings.Add(new(PostVerificationKind.EdgeSpacing, plateNumber, partNumber, null,
-                        $"'{part.BaseDrawing.Name}' is {close.Gap:F3} from the plate's {close.Edge} edge, closer than "
-                        + $"its edge spacing ({close.Spacing:F3}).")
-                    { Location = close.Marker });
-                    continue;
-                }
-                if (region != null && inset > 0 && !outline.Holds(region, inset, origin, Slack))
-                    findings.Add(new(PostVerificationKind.EdgeSpacing, plateNumber, partNumber, null,
-                        $"'{part.BaseDrawing.Name}' is closer than the edge spacing ({inset:F3}) to the plate's outline "
-                        + "or one of its obstacles.")
-                    { Location = Center(profile, part.Location) });
-            }
-            catch (Exception exception) when (IsInvalid(exception))
-            {
-                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, partNumber, null,
-                    "Plate edge check: " + exception.Message));
-            }
-        }
-    }
-
-    private readonly record struct Past(string Edge, double Distance, Vector Marker);
-
-    private readonly record struct Close(string Edge, double Gap, double Spacing, Vector Marker);
-
-    /// <summary>The furthest any non-rapid motion of the placed program runs past the sheet, or null.</summary>
-    private static Past? PastSheet(Part part, Box sheet, CancellationToken cancellationToken)
-    {
-        Past? worst = null;
-        foreach (var move in ExecutionMotionReader.Read(part.Program, part.Location, null, cancellationToken).Motions)
-        {
-            if (move.Rapid || move.Curve == null)
-                continue;
-            var box = move.Curve.ToEntity().BoundingBox;
-            var middle = move.Curve.Midpoint;
-            Consider("left", sheet.Left - box.Left, new Vector(sheet.Left, Clamp(middle.Y, sheet.Bottom, sheet.Top)));
-            Consider("bottom", sheet.Bottom - box.Bottom, new Vector(Clamp(middle.X, sheet.Left, sheet.Right), sheet.Bottom));
-            Consider("right", box.Right - sheet.Right, new Vector(sheet.Right, Clamp(middle.Y, sheet.Bottom, sheet.Top)));
-            Consider("top", box.Top - sheet.Top, new Vector(Clamp(middle.X, sheet.Left, sheet.Right), sheet.Top));
-        }
-        return worst;
-
-        void Consider(string edge, double distance, Vector marker)
-        {
-            if (!double.IsFinite(distance))
-                throw new ArgumentException("Placed program geometry must be finite.");
-            if (distance > Slack && (worst == null || distance > worst.Value.Distance))
-                worst = new Past(edge, distance, marker);
-        }
-    }
-
-    /// <summary>The side whose edge spacing the material falls furthest short of, or null.</summary>
-    private static Close? Shortest(Box bounds, Box sheet, Box work)
-    {
-        Close? worst = null;
-        var shortfall = 0.0;
-        var center = bounds.Center;
-        Consider("left", work.Left - bounds.Left, bounds.Left - sheet.Left, work.Left - sheet.Left,
-            new Vector((sheet.Left + bounds.Left) / 2, center.Y));
-        Consider("bottom", work.Bottom - bounds.Bottom, bounds.Bottom - sheet.Bottom, work.Bottom - sheet.Bottom,
-            new Vector(center.X, (sheet.Bottom + bounds.Bottom) / 2));
-        Consider("right", bounds.Right - work.Right, sheet.Right - bounds.Right, sheet.Right - work.Right,
-            new Vector((sheet.Right + bounds.Right) / 2, center.Y));
-        Consider("top", bounds.Top - work.Top, sheet.Top - bounds.Top, sheet.Top - work.Top,
-            new Vector(center.X, (sheet.Top + bounds.Top) / 2));
-        return worst;
-
-        void Consider(string edge, double by, double gap, double spacing, Vector marker)
-        {
-            if (by > Slack && by > shortfall)
-            {
-                shortfall = by;
-                worst = new Close(edge, System.Math.Max(0, gap), spacing, marker);
-            }
-        }
-    }
-
-    private static Vector Center(ShapeProfile profile, Vector location) =>
-        profile.Perimeter.BoundingBox.Translate(location).Center;
-
-    private static double Clamp(double value, double low, double high) =>
-        double.IsFinite(value) ? System.Math.Clamp(value, low, high) : low;
-
-    private static bool IsInvalid(Exception exception) => exception is
-        ArgumentException or InvalidOperationException or NotSupportedException or ArithmeticException;
-}

OpenNest.Core/Diagnostics/PlateOverlapAnalyzer.cs

@@ -18,7 +18,7 @@ public static class PlateOverlapAnalyzer
     public const double ChordTolerance = 0.001;
 
     /// <summary>
-    /// Capture a whole plate including active clamps, nominal cut-off definitions and part spacing.
+    /// Capture a whole plate including active clamps and nominal cut-off definitions.
     /// Use this entry for the desktop overlap check so manual cut-off contacts
     /// cannot be mistaken for a clear plate merely because cut-offs are not material.
     /// Clamp zones are mapped from the sheet's lower-left frame into the parts' signed
@@ -28,14 +28,12 @@ public static class PlateOverlapAnalyzer
         CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(plate);
-        var parts = plate.Parts.ToArray();
+        var material = Capture(plate.Parts.ToArray(), ClampZoneFrame.ToPlacement(plate).ToArray(),
-        var material = Capture(parts, ClampZoneFrame.ToPlacement(plate).ToArray(),
             cache ?? new OverlapMaterialCache(), cancellationToken);
         var cutoffs = ClampCutDiagnostics.Find(plate);
         cancellationToken.ThrowIfCancellationRequested();
         return new PlateOverlapSnapshot(material.Parts.ToList(), material.Issues.ToList(),
-            material.Clamps.ToList(), cutoffs.ToList(), plate.PartSpacing,
+            material.Clamps.ToList(), cutoffs.ToList());
-            PartSpacingReview.CommonLinePairs(plate, parts));
     }
 
     /// <summary>
@@ -225,16 +223,11 @@ public static class PlateOverlapAnalyzer
         }
         cancellationToken.ThrowIfCancellationRequested();
         var clampFindings = FindClampOverlaps(prepared, snapshot, issues, cancellationToken);
-        var spacingPairs = new List<PlateSpacingPair>();
-        var spacingIssues = new List<PlateOverlapIssue>();
-        PartSpacingReview.Add(snapshot, pairs, issues, spacingPairs, spacingIssues, cancellationToken);
         return new PlateOverlapReport(pairs.OrderBy(pair => pair.PartAId)
             .ThenBy(pair => pair.PartBId).ToList(), issues.OrderBy(issue => issue.PartAId)
             .ThenBy(issue => issue.PartBId).ToList(), snapshot, clampFindings
             .OrderBy(pair => pair.PartAId).ThenBy(pair => pair.PartBId).ToList(),
-            snapshot.CutOffClampFindings.ToList(), spacingPairs.OrderBy(pair => pair.PartAId)
+            snapshot.CutOffClampFindings.ToList());
-            .ThenBy(pair => pair.PartBId).ToList(), spacingIssues.OrderBy(issue => issue.PartAId)
-            .ThenBy(issue => issue.PartBId).ToList());
     }
 
     /// <summary>
@@ -355,10 +348,10 @@ public static class PlateOverlapAnalyzer
             new Vector(zone.Right, zone.Top), new Vector(zone.Left, zone.Top),
             new Vector(zone.Left, zone.Bottom), // Regions repeat their closing vertex exactly.
         };
-        var center = new Vector((zone.Left + zone.Right) / 2, (zone.Bottom + zone.Top) / 2);
+        var centre = new Vector((zone.Left + zone.Right) / 2, (zone.Bottom + zone.Top) / 2);
         return new PlateOverlapPair(part.Input.Id, ClampFindingSlot.IdFor(clamp.Ordinal), part.Input.Name,
-            $"Clamp '{clamp.Id}'", new List<PlateOverlapRegion> { new(corners, zone.Length * zone.Width) }, center,
+            $"Clamp '{clamp.Id}'", new List<PlateOverlapRegion> { new(corners, zone.Length * zone.Width) }, centre,
-            center);
+            centre);
     }
 
     private static Polygon RectanglePolygon(Box box, Vector offset)

OpenNest.Core/Diagnostics/PlateOverlapReport.cs

@@ -9,16 +9,13 @@ public sealed class PlateOverlapReport
 {
     internal PlateOverlapReport(List<PlateOverlapPair> pairs, List<PlateOverlapIssue> issues,
         PlateOverlapSnapshot snapshot, List<PlateOverlapPair> clampFindings = null,
-        List<CutOffClampFinding> cutOffClampFindings = null, List<PlateSpacingPair> spacingPairs = null,
+        List<CutOffClampFinding> cutOffClampFindings = null)
-        List<PlateOverlapIssue> spacingIssues = null)
     {
         Pairs = pairs.AsReadOnly();
         Issues = issues.AsReadOnly();
         Snapshot = snapshot;
         ClampFindings = (clampFindings ?? new List<PlateOverlapPair>()).AsReadOnly();
         CutOffClampFindings = (cutOffClampFindings ?? new List<CutOffClampFinding>()).AsReadOnly();
-        SpacingPairs = (spacingPairs ?? new List<PlateSpacingPair>()).AsReadOnly();
-        SpacingIssues = (spacingIssues ?? new List<PlateOverlapIssue>()).AsReadOnly();
     }
 
     /// <summary>The owned input this report was computed from; the baseline for incremental rechecks.</summary>
@@ -36,22 +33,7 @@ public sealed class PlateOverlapReport
     /// <summary>Nominal cut-off/clamp contacts. Lines have no material area or part pair.</summary>
     public IReadOnlyList<CutOffClampFinding> CutOffClampFindings { get; }
 
-    /// <summary>
+    public bool IsComplete => Issues.Count == 0;
-    /// Pairs that share no material but sit closer than the plate's part spacing. Only a plate
-    /// capture carries the spacing; see <see cref="SpacingChecked"/>.
-    /// </summary>
-    public IReadOnlyList<PlateSpacingPair> SpacingPairs { get; }
-
-    /// <summary>
-    /// Parts or pairs the spacing scan could not read. Kept apart from <see cref="Issues"/>,
-    /// which incremental rechecks reuse by overlap pair.
-    /// </summary>
-    public IReadOnlyList<PlateOverlapIssue> SpacingIssues { get; }
-
-    /// <summary>True when the input required a gap, so empty SpacingPairs means something.</summary>
-    public bool SpacingChecked => PartSpacingReview.Enforces(Snapshot.PartSpacing);
-
-    public bool IsComplete => Issues.Count == 0 && SpacingIssues.Count == 0;
     public double ChordTolerance => PlateOverlapAnalyzer.ChordTolerance;
 }
 
@@ -113,7 +95,7 @@ public sealed class PlateOverlapPair
     /// its pole of inaccessibility, or an interior scan-line point when a thin island defeats
     /// the bounded pole search. Markers, hit testing and inspection rings use this point.
     /// A tolerance-free tiny-clamp finding (a clamp narrower than the chord tolerance) keeps
-    /// its conservative whole-clamp region, so its marker is the clamp's center, within half
+    /// its conservative whole-clamp region, so its marker is the clamp's centre, within half
     /// the clamp's size of the material. Returned by value.
     /// </summary>
     public Vector Marker { get; }
@@ -121,13 +103,6 @@ public sealed class PlateOverlapPair
     public Box Bounds => new(bounds.X, bounds.Y, bounds.Length, bounds.Width);
 }
 
-/// <summary>
-/// Two parts closer than the plate's part spacing, ordered by zero-based input index.
-/// <see cref="Marker"/> is the middle of the narrowest gap, in world coordinates.
-/// </summary>
-public sealed record PlateSpacingPair(int PartAId, int PartBId, string PartAName, string PartBName,
-    double Gap, Vector Marker);
-
 /// <summary>
 /// One connected island of shared material in world coordinates, after hole subtraction:
 /// a counterclockwise outline and its clockwise holes.
@@ -169,15 +144,12 @@ public sealed record PlateOverlapIssue(int PartAId, int? PartBId, string Message
 public sealed class PlateOverlapSnapshot
 {
     internal PlateOverlapSnapshot(List<CapturedOverlapPart> parts, List<PlateOverlapIssue> issues,
-        List<CapturedClamp> clamps = null, List<CutOffClampFinding> cutOffClampFindings = null,
+        List<CapturedClamp> clamps = null, List<CutOffClampFinding> cutOffClampFindings = null)
-        double partSpacing = 0, IReadOnlyDictionary<(int, int), double> commonLinePairs = null)
     {
-        CommonLinePairs = commonLinePairs ?? new Dictionary<(int, int), double>();
         Parts = parts.AsReadOnly();
         Issues = issues.AsReadOnly();
         Clamps = (clamps ?? new List<CapturedClamp>()).AsReadOnly();
         CutOffClampFindings = (cutOffClampFindings ?? new List<CutOffClampFinding>()).AsReadOnly();
-        PartSpacing = partSpacing;
     }
 
     internal IReadOnlyList<CapturedOverlapPart> Parts { get; }
@@ -186,13 +158,6 @@ public sealed class PlateOverlapSnapshot
     /// <summary>Owned clamp keep-out rectangles in plate coordinates, capture order.</summary>
     internal IReadOnlyList<CapturedClamp> Clamps { get; }
     internal IReadOnlyList<CutOffClampFinding> CutOffClampFindings { get; }
-
-    /// <summary>The plate's part spacing; zero (no spacing check) for a bare group of parts.</summary>
-    internal double PartSpacing { get; }
-
-    /// <summary>Part ids (lower first) of each pair in one common-line group, with its kerf: held to
-    /// the kerf instead of <see cref="PartSpacing"/>.</summary>
-    internal IReadOnlyDictionary<(int, int), double> CommonLinePairs { get; }
 }
 
 internal sealed record CapturedOverlapPart(int Id, string Name, OverlapSource Source,

OpenNest.Core/Diagnostics/PostVerificationAnalyzer.cs

@@ -19,15 +19,12 @@ public static class PostVerificationAnalyzer
         CancellationToken cancellationToken = default)
     {
         var report = Analyze(nest, cancellationToken);
-        var change = postProcessor is IPostVerificationSupport support
+        if (postProcessor is IPostVerificationSupport { PreservesPlacedProgramOrder: true })
-            ? support.PlacedProgramOrderChange(nest)
-            : "does not declare that it preserves placed part/contour order and pierce positions";
-        if (change == null)
             return report;
         var findings = report.Findings.ToList();
         findings.Add(new(PostVerificationKind.Incomplete, 0, null, null,
-            $"Post '{postProcessor?.Name ?? "unknown"}' {change}. " +
+            $"Post '{postProcessor?.Name ?? "unknown"}' does not declare that it preserves placed part/contour order " +
-            "Nest-level checks ran, but the final rapid sequence requires manual review."));
+            "and pierce positions. Nest-level checks ran, but the final rapid sequence requires manual review."));
         return new PostVerificationReport(findings);
     }
 
@@ -104,13 +101,7 @@ public static class PostVerificationAnalyzer
                         "Clamp/cut-off check: " + exception.Message));
                 }
             }
-            // A common-line member cut once ends in open remainder pieces that cut it free.
+            var obstacles = new ReleasedContourState();
-            var members = (plate.CommonLines ?? [])
-                .SelectMany(group => group.Members)
-                .Select(member => plate.Parts.IndexOf(member) + 1)
-                .Where(number => number > 0)
-                .ToHashSet();
-            var obstacles = new ReleasedContourState(true, null, members.Count == 0 ? null : members.Contains);
             Vector? position = startPoint;
             for (var index = 0; index < plate.Parts.Count; index++)
             {
@@ -144,16 +135,12 @@ public static class PostVerificationAnalyzer
                     if (part == null || !double.IsFinite(part.Rotation))
                         throw new ArgumentException("Missing part or invalid rotation.");
                     var moves = ExecutionMotionReader.Read(part.Program, part.Location, position, cancellationToken).Motions;
-                    // Executed reads stop at an applied program's display tail, so any display
-                    // perimeter left is an unplanned blank whose outline a post would refuse.
-                    if (moves.Any(move => move.Layer == LayerType.DisplayPerimeter))
-                        Incomplete("This part has a display perimeter (a supplied blank's outline that is never cut) "
-                            + "but no cutting plan; posts refuse it. Plan cutting first (Plate > Plan Cutting..., or --plan-cutting) so only its cutouts are cut.");
                     if (expectsCuts && !moves.Any(move => !move.Rapid
                         && move.Layer is LayerType.Cut or LayerType.Display
                         && move.Curve.Length > PostVerificationGeometry.Epsilon))
                         Incomplete("Placed program has no cutting contour motions for this drawing.");
-                    obstacles.AnalyzeMoves(moves, cutoff, findings, plateNumber, partNumber, cancellationToken);
+                    obstacles.AnalyzeMoves(moves, cutoff, findings, plateNumber, partNumber, cancellationToken,
+                        proveOpenCuts: true);
                     if (clamps is { Count: > 0 })
                         foreach (var move in moves)
                         {
@@ -232,12 +219,6 @@ public static class PostVerificationAnalyzer
                     issue.PartBId is { } other ? indices[other] : null, "Overlap check: " + issue.Message));
             // Parts that do not overlap may still be closer than the plate's part spacing.
             PartSpacingReview.Add(plate, plateNumber, materialParts, indices, overlap, findings, cancellationToken);
-            // Parts must stay on the sheet and keep its edge spacing.
-            PlateEdgeReview.Add(plate, plateNumber, findings, cancellationToken);
-            // Parts the support bed cannot hold level need a tab that keeps them level.
-            PartSupportReview.Add(plate, plateNumber, findings, cancellationToken);
-            // Common-line groups still share their spans at the kerf, and no lead cuts a partner.
-            CommonLineReview.Add(plate, plateNumber, findings, cancellationToken);
         }
         cancellationToken.ThrowIfCancellationRequested();
         return new PostVerificationReport(findings);

OpenNest.Core/Diagnostics/PostVerificationGeometry.cs

@@ -49,7 +49,7 @@ internal static class PostVerificationGeometry
         /// <summary>
         /// The relative rounding allowance of native line/circle intersections. Their discriminant
         /// b^2 - 4ac cancels: its absolute error stays below about 30 units of roundoff times
-        /// |d1|^2 (|d2|^2 + r^2) (d1 the line, d2 from the circle's center to the line's start), so a
+        /// |d1|^2 (|d2|^2 + r^2) (d1 the line, d2 from the circle's centre to the line's start), so a
         /// spurious root can lie at most about 1e-7 times the span of both extents beyond the true
         /// distance between line and circle (about 2e-9 is seen in practice). A long lead beside a
         /// small circle needs the full check; a short lead beside a nearby part does not.
@@ -68,10 +68,6 @@ internal static class PostVerificationGeometry
             return IsClearOf(other, ClearMargin + reach + SpanRounding * span);
         }
 
-        /// <summary>True when <paramref name="point"/> lies within the extent, its edges included.</summary>
-        internal bool Contains(Vector point) =>
-            point.X >= MinX && point.X <= MaxX && point.Y >= MinY && point.Y <= MaxY;
-
         /// <summary>True when <paramref name="y"/> lies more than <see cref="ClearMargin"/> outside the Y range.</summary>
         internal bool IsClearOfRow(double y) => IsWellConditioned && System.Math.Abs(y) <= WellConditionedLimit
             && (y > MaxY + ClearMargin || y < MinY - ClearMargin);
@@ -82,7 +78,7 @@ internal static class PostVerificationGeometry
 
         // Math.Max propagates NaN and no comparison with NaN holds, so NaN and infinite bounds
         // (including the empty extent's) fail this test too.
-        internal bool IsWellConditioned =>
+        private bool IsWellConditioned =>
             System.Math.Max(System.Math.Max(System.Math.Abs(MinX), System.Math.Abs(MaxX)),
                 System.Math.Max(System.Math.Abs(MinY), System.Math.Abs(MaxY))) <= WellConditionedLimit;
     }
@@ -114,56 +110,17 @@ internal static class PostVerificationGeometry
         // If there are no contacts except possibly departure, all open-segment points
         // have the same inside/outside status. A midpoint catches travel entirely inside
         // and departure into the interior, without flagging start-only outward contact.
-        return Inside(start + delta * 0.5, curves, token);
+        var midpoint = start + delta * 0.5;
-    }
-
-    /// <summary>
-    /// Ray parity of <paramref name="point"/> against closed <paramref name="curves"/>, cast at
-    /// <see cref="RayY"/> so no vertex of them lies on the ray.
-    /// </summary>
-    internal static bool Inside(Vector point, IReadOnlyList<Curve> curves, CancellationToken token)
-    {
-        var rayY = RayY(point, curves, token);
         var inside = false;
         foreach (var curve in curves)
         {
             token.ThrowIfCancellationRequested();
-            if (curve.CrossesRay(point, rayY))
+            if (curve.CrossesRay(midpoint))
                 inside = !inside;
         }
         return inside;
     }
 
-    /// <summary>
-    /// The height a parity ray from <paramref name="point"/> runs at: just above it, by about
-    /// <see cref="RaySeamTolerance"/>, and clear of every vertex height of <paramref name="curves"/>.
-    /// The two copies of a seam vertex can differ in the last bits; a ray running between them
-    /// counts one edge and not the other, so a point that happens to sit a tolerance below another
-    /// contour's vertex (text baselines a micro-inch apart) would read as inside it.
-    /// </summary>
-    internal static double RayY(Vector point, IReadOnlyList<Curve> curves, CancellationToken token)
-    {
-        const int steps = 8;
-        const double band = RaySeamTolerance / (4 * steps);
-        for (var step = 0; step < steps; step++)
-        {
-            var rayY = point.Y + RaySeamTolerance * (1 + (double)step / steps);
-            var clear = true;
-            foreach (var curve in curves)
-            {
-                token.ThrowIfCancellationRequested();
-                if (curve.HasVertexNear(rayY, band))
-                {
-                    clear = false;
-                    break;
-                }
-            }
-            if (clear)
-                return rayY;
-        }
-        return point.Y + RaySeamTolerance;
-    }
-
     internal static IReadOnlyList<Vector> ContactPoints(Vector start, Vector end,
         IReadOnlyList<Curve> curves, CancellationToken token)
     {
@@ -322,18 +279,6 @@ internal static class PostVerificationGeometry
         /// <summary>Exact native distance from <paramref name="point"/> to this finite curve.</summary>
         internal double DistanceTo(Vector point) => nativeEntity.Value.ClosestPointTo(point).DistanceTo(point);
 
-        /// <summary>The native point of this finite curve closest to <paramref name="point"/>.</summary>
-        internal Vector ClosestPoint(Vector point) => nativeEntity.Value.ClosestPointTo(point);
-
-        /// <summary>
-        /// This curve from its start up to <paramref name="point"/>, which must be one of its own
-        /// interior points (see <see cref="ClosestPoint"/>); an arc keeps its center and radius.
-        /// </summary>
-        internal Curve Until(Vector point) => Center is { } center
-            ? new Curve(Start, point, center, Radius,
-                System.Math.Sign(Sweep) * Travel(System.Math.Atan2(point.Y - center.Y, point.X - center.X)))
-            : new Curve(Start, point, null, 0, 0);
-
         internal bool Contains(Vector point) => Contains(point, Epsilon);
 
         /// <summary>On-support test with an admitted positional allowance (see <see cref="SameSupport(Curve, double)"/>).</summary>
@@ -351,53 +296,33 @@ internal static class PostVerificationGeometry
 
         internal IReadOnlyList<Vector> Contacts(Curve other, out bool overlap)
         {
-            var same = SameSupport(other);
+            var entity = nativeEntity.Value;
-            // Two curves that meet end to end share that vertex, and the native query is
+            var candidate = other.nativeEntity.Value;
-            // ill-conditioned there: circles meeting at a shallow angle, or a line meeting its own
+            // Native arc filters discard NaN supporting-circle intersections. Inspect
-            // fillet, put their root up to 1e-5 off the joint, which no joint tolerance can tell
+            // both unfiltered queries first: roundoff can differ by operand direction.
-            // from a cut that touches beside it, and a fillet's circle tangent inside the arc it
+            // Coincident supports have separate overlap handling below.
-            // continues gives the supporting-circle query no root at all. Both shapes are known,
+            if (Center is { } center && other.Center is { } otherCenter && !SameSupport(other))
-            // so their other intersection, if there is one, follows from the shared vertex
+            {
-            // exactly instead, and no native query runs for the pair.
+                var support = new Circle(center, Radius);
-            var joint = same ? null : SharedVertex(other);
+                var otherSupport = new Circle(otherCenter, other.Radius);
+                support.Intersects(otherSupport, out var forward);
+                otherSupport.Intersects(support, out var reverse);
+                foreach (var point in forward)
+                    Validate(point);
+                foreach (var point in reverse)
+                    Validate(point);
+            }
             List<Vector> points;
-            if (joint is { } vertex)
+            bool intersects;
+            switch (candidate)
             {
-                points = [vertex];
+                case Line line: intersects = entity.Intersects(line, out points); break;
-                if (SecondIntersection(other, vertex) is { } second && second.DistanceTo(vertex) > Epsilon
+                case Arc arc: intersects = entity.Intersects(arc, out points); break;
-                    && Contains(second) && other.Contains(second)
+                case Circle circle: intersects = entity.Intersects(circle, out points); break;
-                    && !IsOutsideArcSpan(second) && !other.IsOutsideArcSpan(second))
+                default: throw new NotSupportedException("Unsupported native boundary.");
-                    points.Add(second);
-            }
-            else
-            {
-                var entity = nativeEntity.Value;
-                var candidate = other.nativeEntity.Value;
-                // Native arc filters discard NaN supporting-circle intersections. Inspect
-                // both unfiltered queries first: roundoff can differ by operand direction.
-                // Coincident supports have separate overlap handling below.
-                if (Center is { } center && other.Center is { } otherCenter && !same)
-                {
-                    var support = new Circle(center, Radius);
-                    var otherSupport = new Circle(otherCenter, other.Radius);
-                    support.Intersects(otherSupport, out var forward);
-                    otherSupport.Intersects(support, out var reverse);
-                    foreach (var point in forward)
-                        Validate(point);
-                    foreach (var point in reverse)
-                        Validate(point);
-                }
-                bool intersects;
-                switch (candidate)
-                {
-                    case Line line: intersects = entity.Intersects(line, out points); break;
-                    case Arc arc: intersects = entity.Intersects(arc, out points); break;
-                    case Circle circle: intersects = entity.Intersects(circle, out points); break;
-                    default: throw new NotSupportedException("Unsupported native boundary.");
-                }
-                if (!intersects)
-                    points.Clear();
             }
+            if (!intersects)
+                points.Clear();
             // Coincident circles produce NaNs in the native discrete-contact query.
             // Their support overlap is handled separately, without inventing crossings.
             // Supports that agree only within Epsilon (arcs of one circle whose centers were
@@ -406,25 +331,24 @@ internal static class PostVerificationGeometry
             // still refuse, while arcs that only meet at a joint or lie apart are not overlap.
             var witness = Center is { } c && other.Center is { } oc
                 && (c.X != oc.X || c.Y != oc.Y || Radius != other.Radius) ? RaySeamTolerance : Epsilon;
-            overlap = same && (InteriorWitness(Midpoint, other, witness)
+            overlap = SameSupport(other) && (InteriorWitness(Midpoint, other, witness)
                 || InteriorWitness(other.Midpoint, this, witness)
                 || InteriorWitness(Start, other, witness) || InteriorWitness(End, other, witness)
                 || InteriorWitness(other.Start, this, witness) || InteriorWitness(other.End, this, witness));
-            if (same)
+            if (SameSupport(other))
                 points.Clear();
             foreach (var point in points)
                 Validate(point);
-            // Analytic contacts of adjacent curves are certain; the ray guard below is for native queries.
+            var nativeContactCount = points.Count;
-            var nativeContactCount = joint.HasValue ? int.MaxValue : points.Count;
             foreach (var point in new[] { Start, End, other.Start, other.End })
                 if (Contains(point) && other.Contains(point)
                     && !points.Exists(p => p.DistanceTo(point) <= Epsilon))
                     points.Add(point);
             // Existing exact line/ray contact semantics guard native queries which
             // suppress very short or nearly parallel intersections. Uncertainty refuses.
-            if (Center is null && !SameSupport(other) && nativeContactCount == 0 && ExactLineContact(this, other, points))
+            if (Center is null && !SameSupport(other) && nativeContactCount == 0 && ExactLineContact(this, other))
                 throw new NotSupportedException("Native contact query is numerically uncertain.");
-            if (other.Center is null && Center.HasValue && nativeContactCount == 0 && ExactLineContact(other, this, points))
+            if (other.Center is null && Center.HasValue && nativeContactCount == 0 && ExactLineContact(other, this))
                 throw new NotSupportedException("Native contact query is numerically uncertain.");
             return points;
 
@@ -433,49 +357,6 @@ internal static class PostVerificationGeometry
                     || (point.DistanceTo(curve.Start) > tolerance && point.DistanceTo(curve.End) > tolerance));
         }
 
-        /// <summary>
-        /// The end this curve and <paramref name="other"/> share, within <see cref="Epsilon"/>, as
-        /// this curve has it; null when they share none or either is a full circle.
-        /// </summary>
-        private Vector? SharedVertex(Curve other)
-        {
-            if (Center.HasValue && !IsFiniteArc || other.Center.HasValue && !other.IsFiniteArc)
-                return null;
-            foreach (var end in new[] { End, Start })
-                if (end.DistanceTo(other.Start) <= Epsilon || end.DistanceTo(other.End) <= Epsilon)
-                    return end;
-            return null;
-        }
-
-        /// <summary>
-        /// Where the supports of this curve and <paramref name="other"/> meet again, given that
-        /// they meet at <paramref name="vertex"/>: two circles meet again at the vertex's mirror
-        /// image across the line through their centers, and a line meets a circle again at the
-        /// far end of its chord through the vertex. Two lines meet only once. The result is on
-        /// both supports; it may be the vertex itself (tangency) or off either finite span.
-        /// </summary>
-        private Vector? SecondIntersection(Curve other, Vector vertex)
-        {
-            if (Center is { } center && other.Center is { } otherCenter)
-            {
-                var axis = otherCenter - center;
-                var distance = otherCenter.DistanceTo(center);
-                if (distance <= Epsilon)
-                    return null;
-                var unit = axis * (1 / distance);
-                var foot = center + unit * Dot(vertex - center, unit);
-                return foot * 2 - vertex;
-            }
-            if (Center is null && other.Center is null)
-                return null;
-            var line = Center is null ? this : other;
-            var circle = Center is null ? other.Center!.Value : Center!.Value;
-            if (line.Length <= Epsilon)
-                return null;
-            var direction = (line.End - line.Start) * (1 / line.Length);
-            return vertex + direction * (2 * Dot(circle - vertex, direction));
-        }
-
         /// <summary>
         /// Whether exact ray semantics find <paramref name="curve"/> touching <paramref name="line"/>
         /// anywhere except at a line endpoint the curve contains, which is already a recorded contact.
@@ -483,35 +364,16 @@ internal static class PostVerificationGeometry
         /// endpoint (both stop half-way when both endpoints are contained): a line meeting a
         /// tangent arc at their shared vertex is otherwise rediscovered there as a contact the
         /// native query missed, because rounding can drop the tangent root of its quadratic.
-        /// For the same reason a ray hit within <see cref="RaySeamTolerance"/> of a
-        /// <paramref name="recorded"/> contact is that contact: an arc lead ending tangent on a
-        /// straight edge, mid-edge, has its end recorded and its double root dropped.
         /// </summary>
-        private static bool ExactLineContact(Curve line, Curve curve, IReadOnlyList<Vector> recorded)
+        private static bool ExactLineContact(Curve line, Curve curve)
         {
             var direction = (line.End - line.Start) * (1 / line.Length);
             var startRecorded = curve.Contains(line.Start);
             var endRecorded = curve.Contains(line.End);
             var forward = endRecorded ? startRecorded ? line.Length / 2 : 0 : line.Length;
             var backward = startRecorded ? endRecorded ? line.Length / 2 : 0 : line.Length;
-            return (forward > 0 && Unrecorded(line.Start, direction, forward))
+            return (forward > 0 && curve.ContactAfterStart(line.Start, direction, forward))
-                || (backward > 0 && Unrecorded(line.End, direction * -1, backward));
+                || (backward > 0 && curve.ContactAfterStart(line.End, direction * -1, backward));
-
-            bool Unrecorded(Vector origin, Vector ray, double length)
-            {
-                var hits = new List<double>();
-                curve.ContactAfterStart(origin, ray, length, hits);
-                foreach (var distance in hits)
-                {
-                    var hit = origin + ray * distance;
-                    var known = false;
-                    foreach (var point in recorded)
-                        known |= point.DistanceTo(hit) <= RaySeamTolerance;
-                    if (!known)
-                        return true;
-                }
-                return false;
-            }
         }
 
 
@@ -537,11 +399,11 @@ internal static class PostVerificationGeometry
             point.X - Center.Value.X)) <= System.Math.Abs(Sweep) + Epsilon / Radius
             || point.DistanceTo(Start) <= Epsilon || point.DistanceTo(End) <= Epsilon;
 
-        // How far past r^2 a squared distance from the center still counts as touching the arc.
+        // How far past r^2 a squared distance from the centre still counts as touching the arc.
         // For small arcs this band reaches well beyond the radius (sqrt(1e-8) = 1e-4 as r -> 0).
         private double ContactSlack => Epsilon * System.Math.Max(1, Radius * 2);
 
-        // The largest distance from the center that ContactAfterStart can count as contact.
+        // The largest distance from the centre that ContactAfterStart can count as contact.
         private double ContactReach => System.Math.Sqrt(Radius * Radius + ContactSlack);
 
         internal bool ContactAfterStart(Vector origin, Vector direction, double length,
@@ -593,20 +455,7 @@ internal static class PostVerificationGeometry
             }
         }
 
-        /// <summary>
+        internal bool CrossesRay(Vector point)
-        /// Whether an endpoint, or the top or bottom of an arc's circle, lies within
-        /// <paramref name="band"/> of height <paramref name="y"/>.
-        /// </summary>
-        internal bool HasVertexNear(double y, double band) =>
-            System.Math.Abs(Start.Y - y) <= band || System.Math.Abs(End.Y - y) <= band
-            || Center is { } center && (System.Math.Abs(center.Y + Radius - y) <= band
-                || System.Math.Abs(center.Y - Radius - y) <= band);
-
-        /// <summary>
-        /// Whether a ray running in +X from <paramref name="point"/>, at height
-        /// <paramref name="rayY"/> (see <see cref="RayY"/>), crosses this curve.
-        /// </summary>
-        internal bool CrossesRay(Vector point, double rayY)
         {
             // Ray parity needs both edges meeting at a shared vertex to agree which side of the ray
             // that vertex is on. Rings are only nominally closed: capture admits closure seams and
@@ -617,6 +466,7 @@ internal static class PostVerificationGeometry
             // edges; real features (notches, tabs, arc spans) are far larger than the tolerance and
             // still count. Containment of a point that itself lies within the tolerance of a
             // boundary edge stays ambiguous by design, exactly as it was before.
+            var rayY = point.Y + RaySeamTolerance;
             if (Center is not { } center)
                 return (Start.Y > rayY) != (End.Y > rayY)
                     && Start.X + (point.Y - Start.Y) * (End.X - Start.X) / (End.Y - Start.Y) > point.X;

OpenNest.Core/Diagnostics/PostVerificationReport.cs

@@ -34,31 +34,7 @@ public enum PostVerificationKind
     /// Two parts are closer than the plate's part spacing without sharing material, judged as
     /// Auto Nest's layout check judges them.
     /// </summary>
-    PartSpacing,
+    PartSpacing
-
-    /// <summary>
-    /// A part its plate's support bed cannot hold level has no tab that keeps it level, so it may
-    /// tip once cut free (see docs/support-tabs.md).
-    /// </summary>
-    PartSupport,
-
-    /// <summary>
-    /// A part's cuts, leads or scribes run past the sheet, or its material lies outside an outlined
-    /// sheet or over one of its obstacles.
-    /// </summary>
-    OffPlate,
-
-    /// <summary>
-    /// A part's clean material is closer to the sheet's edge than the plate's edge spacing, judged as
-    /// Auto Nest's layout check judges it.
-    /// </summary>
-    EdgeSpacing,
-
-    /// <summary>
-    /// A common-line group (see docs/common-line-cutting.md) no longer shares its spans one kerf
-    /// apart, was placed for another kerf, or a member's lead runs into its partner.
-    /// </summary>
-    CommonLine
 }
 
 /// <summary>Plate and part numbers are one-based; plate zero denotes a whole-post limitation.</summary>
@@ -108,14 +84,6 @@ public sealed class PostVerificationReport
             Summary(PostVerificationKind.PierceZone, "Pierce zones");
         if (Findings.Any(finding => finding.Kind == PostVerificationKind.PartSpacing))
             Summary(PostVerificationKind.PartSpacing, "Part spacing");
-        if (Findings.Any(finding => finding.Kind == PostVerificationKind.PartSupport))
-            Summary(PostVerificationKind.PartSupport, "Part support");
-        if (Findings.Any(finding => finding.Kind == PostVerificationKind.OffPlate))
-            Summary(PostVerificationKind.OffPlate, "Off the plate");
-        if (Findings.Any(finding => finding.Kind == PostVerificationKind.EdgeSpacing))
-            Summary(PostVerificationKind.EdgeSpacing, "Edge spacing");
-        if (Findings.Any(finding => finding.Kind == PostVerificationKind.CommonLine))
-            Summary(PostVerificationKind.CommonLine, "Common lines");
         foreach (var finding in Findings)
         {
             text.Append(finding.PlateNumber == 0 ? "Post processor" : $"Plate {finding.PlateNumber}");

OpenNest.Core/Dimensions/DimensionBuilder.cs

@@ -1,234 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Converters;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.Dimensions
-{
-    /// <summary>
-    /// Resolves dimensions against the entities being cut (visible, with roles, breakoffs and
-    /// tabbed cutouts applied), so a dimension measures the part as it will come off the table.
-    /// Radius and diameter dimensions find their circle or arc by ID among the visible entities.
-    /// </summary>
-    public static class DimensionBuilder
-    {
-        private const double DefaultOffsetFactor = 0.1;
-        private const double RadialOffsetFactor = 0.05;
-
-        /// <summary>
-        /// The extents of the geometry that bounds the part, or null if there is none. Source marks
-        /// keep their own layer objects, so <see cref="SpecialLayers.IsMaterial"/> alone would count
-        /// them; break cuts are skipped because they stay inside the outline they join.
-        /// </summary>
-        public static Box Extents(IEnumerable<Entity> entities)
-        {
-            var measured = Measured(entities);
-            return measured.Count == 0 ? null : measured.GetBoundingBox();
-        }
-
-        private static List<Entity> Measured(IEnumerable<Entity> entities) =>
-            entities
-                .Where(e => SpecialLayers.IsMaterial(e.Layer) && !ScribeLayerRepair.IsMarkLayer(e.Layer))
-                .ToList();
-
-        public static DimensionLayout Layout(IEnumerable<Entity> entities, DrawingDimension dimension)
-        {
-            var kind = dimension.Kind;
-            if (dimension.Offset == 0 || !double.IsFinite(dimension.Offset))
-                return new DimensionLayout { Kind = kind, Error = "its offset is not usable" };
-
-            if (dimension.IsRadial)
-                return RadialLayout(entities, dimension);
-
-            var measured = Measured(entities);
-            if (measured.Count == 0)
-                return new DimensionLayout { Kind = kind, Error = "there is no cut geometry to measure" };
-
-            var box = measured.GetBoundingBox();
-
-            var offset = dimension.Offset;
-            if (kind == DimensionKind.OverallHorizontal)
-            {
-                if (box.Length <= 0)
-                    return new DimensionLayout { Kind = kind, Error = "the part has no horizontal size" };
-
-                var edge = offset > 0 ? box.Top : box.Bottom;
-                return new DimensionLayout
-                {
-                    Kind = kind,
-                    Extents = box,
-                    Profile = measured,
-                    Value = box.Length,
-                    ExtensionStart = new Vector(box.Left, edge),
-                    ExtensionEnd = new Vector(box.Right, edge),
-                    LineStart = new Vector(box.Left, edge + offset),
-                    LineEnd = new Vector(box.Right, edge + offset),
-                };
-            }
-
-            if (box.Width <= 0)
-                return new DimensionLayout { Kind = kind, Error = "the part has no vertical size" };
-
-            var side = offset > 0 ? box.Right : box.Left;
-            return new DimensionLayout
-            {
-                Kind = kind,
-                Extents = box,
-                Profile = measured,
-                Value = box.Width,
-                ExtensionStart = new Vector(side, box.Bottom),
-                ExtensionEnd = new Vector(side, box.Top),
-                LineStart = new Vector(side + offset, box.Bottom),
-                LineEnd = new Vector(side + offset, box.Top),
-            };
-        }
-
-        /// <summary>
-        /// The overall dimensions <paramref name="existing"/> does not have yet, below and to the
-        /// right of the part and a tenth of its larger size away. Empty when there is nothing to
-        /// measure.
-        /// </summary>
-        public static List<DrawingDimension> MissingOverall(IEnumerable<Entity> entities,
-            IEnumerable<DrawingDimension> existing)
-        {
-            var added = new List<DrawingDimension>();
-            var box = Extents(entities);
-            if (box == null)
-                return added;
-
-            var offset = System.Math.Max(box.Length, box.Width) * DefaultOffsetFactor;
-            if (offset <= 0)
-                return added;
-
-            var kinds = existing.Select(d => d.Kind).ToHashSet();
-            if (!kinds.Contains(DimensionKind.OverallHorizontal))
-                added.Add(new DrawingDimension { Kind = DimensionKind.OverallHorizontal, Offset = -offset });
-            if (!kinds.Contains(DimensionKind.OverallVertical))
-                added.Add(new DrawingDimension { Kind = DimensionKind.OverallVertical, Offset = offset });
-            return added;
-        }
-
-        /// <summary>
-        /// A <paramref name="kind"/> dimension for each circle or arc in <paramref name="curves"/>
-        /// that does not have one yet. On a circle the leader points up and right for a radius and
-        /// up and left for a diameter, so the two do not overlap; on an arc it points through the
-        /// middle. The label sits outside the curve by half its radius, or a twentieth of
-        /// the part's larger size when that is more.
-        /// </summary>
-        public static List<DrawingDimension> MissingRadial(IEnumerable<Entity> curves, DimensionKind kind,
-            IEnumerable<Entity> part, IEnumerable<DrawingDimension> existing)
-        {
-            var added = new List<DrawingDimension>();
-            if (!DrawingDimension.IsRadialKind(kind))
-                return added;
-
-            var box = Extents(part);
-            var partSize = box == null ? 0 : System.Math.Max(box.Length, box.Width);
-            var taken = existing.Where(d => d.Kind == kind).Select(d => d.EntityId).ToHashSet();
-            foreach (var curve in curves)
-            {
-                if (curve.Id == Guid.Empty || !taken.Add(curve.Id) || !TryCurve(curve, out _, out var radius, out var arc))
-                    continue;
-                added.Add(new DrawingDimension
-                {
-                    Kind = kind,
-                    EntityId = curve.Id,
-                    Angle = arc != null ? MidAngle(arc)
-                        : kind == DimensionKind.Radius ? Angle.HalfPI / 2 : Angle.HalfPI * 1.5,
-                    Offset = System.Math.Max(radius / 2, partSize * RadialOffsetFactor),
-                });
-            }
-            return added;
-        }
-
-        /// <summary>Whether <paramref name="entity"/> is a circle or arc a radius or diameter can measure.</summary>
-        public static bool IsRadialTarget(Entity entity) => TryCurve(entity, out _, out _, out _);
-
-        private static bool TryCurve(Entity entity, out Vector center, out double radius, out Arc arc)
-        {
-            arc = null;
-            switch (entity)
-            {
-                case Circle circle:
-                    center = circle.Center;
-                    radius = circle.Radius;
-                    break;
-                case Arc a:
-                    center = a.Center;
-                    radius = a.Radius;
-                    arc = a.IsFullCircle() ? null : a;
-                    break;
-                default:
-                    center = default;
-                    radius = 0;
-                    return false;
-            }
-            return radius > 0 && double.IsFinite(radius);
-        }
-
-        private static DimensionLayout RadialLayout(IEnumerable<Entity> entities, DrawingDimension dimension)
-        {
-            var kind = dimension.Kind;
-            if (!double.IsFinite(dimension.Angle))
-                return new DimensionLayout { Kind = kind, Error = "its leader angle is not usable" };
-
-            var entity = dimension.EntityId == Guid.Empty
-                ? null
-                : entities.FirstOrDefault(e => e.Id == dimension.EntityId);
-            if (entity == null)
-                return new DimensionLayout { Kind = kind, Error = "its circle or arc is not cut" };
-            if (!TryCurve(entity, out var center, out var radius, out var arc))
-                return new DimensionLayout { Kind = kind, Error = "it no longer measures a circle or arc" };
-
-            var reach = radius + dimension.Offset;
-            if (reach <= 0)
-                return new DimensionLayout { Kind = kind, Error = "its offset is not usable" };
-
-            var angle = arc != null && kind == DimensionKind.Radius
-                ? ClampToSweep(arc, dimension.Angle)
-                : dimension.Angle;
-            var direction = new Vector(System.Math.Cos(angle), System.Math.Sin(angle));
-            var arrow = center + direction * radius;
-            var far = center - direction * radius;
-            return new DimensionLayout
-            {
-                Kind = kind,
-                Value = kind == DimensionKind.Diameter ? radius * 2 : radius,
-                Center = center,
-                Radius = radius,
-                Angle = angle,
-                Arc = arc,
-                ArrowPoint = arrow,
-                FarArrowPoint = far,
-                LineStart = kind == DimensionKind.Diameter ? far : center,
-                LineEnd = center + direction * reach,
-                Extents = new Box(center.X - radius, center.Y - radius, radius * 2, radius * 2),
-            };
-        }
-
-        /// <summary><paramref name="angle"/> if it is on the arc's sweep, else the nearer end's angle.</summary>
-        public static double ClampToSweep(Arc arc, double angle)
-        {
-            if (Angle.IsBetweenRad(angle, arc.StartAngle, arc.EndAngle, arc.IsReversed))
-                return angle;
-            var toStart = AngularDistance(angle, arc.StartAngle);
-            var toEnd = AngularDistance(angle, arc.EndAngle);
-            return toStart <= toEnd ? arc.StartAngle : arc.EndAngle;
-        }
-
-        private static double AngularDistance(double a, double b)
-        {
-            var d = Angle.NormalizeRad(a - b);
-            return System.Math.Min(d, Angle.TwoPI - d);
-        }
-
-        private static double MidAngle(Arc arc)
-        {
-            // SweepAngle runs counterclockwise from the start, or from the end on a reversed arc.
-            var from = arc.IsReversed ? arc.EndAngle : arc.StartAngle;
-            return Angle.NormalizeRad(from + arc.SweepAngle() / 2);
-        }
-    }
-}

OpenNest.Core/Dimensions/DimensionLayout.cs

@@ -1,148 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using OpenNest.Geometry;
-
-namespace OpenNest.Dimensions
-{
-    /// <summary>
-    /// A dimension resolved against a part's geometry. Extension lines run along the extents, on
-    /// the lines through <see cref="ExtensionStart"/> and <see cref="LineStart"/> and through
-    /// <see cref="ExtensionEnd"/> and <see cref="LineEnd"/>, out from the part to
-    /// <see cref="ExtensionTip"/>; the dimension line joins the last two.
-    /// </summary>
-    public sealed class DimensionLayout
-    {
-        private const int MaxExtensionSteps = 64;
-        private const double ExtensionPrecision = 0.05;
-
-        public DimensionKind Kind { get; init; }
-
-        /// <summary>Why the dimension could not be resolved; null when it was.</summary>
-        public string Error { get; init; }
-
-        public bool IsValid => Error == null;
-
-        public double Value { get; init; }
-        public Vector ExtensionStart { get; init; }
-        public Vector ExtensionEnd { get; init; }
-        public Vector LineStart { get; init; }
-        public Vector LineEnd { get; init; }
-
-        /// <summary>The part's extents the dimension was measured from.</summary>
-        public Box Extents { get; init; }
-
-        /// <summary>The geometry behind <see cref="Extents"/>.</summary>
-        public IReadOnlyList<Entity> Profile { get; init; } = Array.Empty<Entity>();
-
-        public string ValueText => Value.ToString("0.000", CultureInfo.InvariantCulture);
-
-        /// <summary>The value as drawn: radius and diameter carry their drafting prefix.</summary>
-        public string DisplayText => Kind switch
-        {
-            DimensionKind.Radius => "R" + ValueText,
-            DimensionKind.Diameter => "\u00D8" + ValueText,
-            _ => ValueText,
-        };
-
-        public Vector MidPoint => new((LineStart.X + LineEnd.X) / 2, (LineStart.Y + LineEnd.Y) / 2);
-
-        public bool IsRadial => DrawingDimension.IsRadialKind(Kind);
-
-        // Radius and diameter: the leader runs from LineStart (the center for a radius, the far
-        // side of the curve for a diameter) through ArrowPoint on the curve to LineEnd, the label.
-
-        /// <summary>Radius and diameter: the measured curve's center.</summary>
-        public Vector Center { get; init; }
-
-        /// <summary>Radius and diameter: the measured curve's radius.</summary>
-        public double Radius { get; init; }
-
-        /// <summary>Radius and diameter: the leader's direction from the center, in radians.</summary>
-        public double Angle { get; init; }
-
-        /// <summary>Radius and diameter: where the leader meets the curve on the label's side.</summary>
-        public Vector ArrowPoint { get; init; }
-
-        /// <summary>Diameter: where the leader meets the curve opposite <see cref="ArrowPoint"/>.</summary>
-        public Vector FarArrowPoint { get; init; }
-
-        /// <summary>Radius and diameter on an arc: the measured arc; null for a circle.</summary>
-        public Arc Arc { get; init; }
-
-        /// <summary>
-        /// Radius and diameter: the leader angle and offset that put the label at
-        /// <paramref name="point"/>, with the label at least <paramref name="minimum"/> from both the
-        /// curve and the center. A radius on an arc stays on the arc's sweep.
-        /// </summary>
-        public (double Offset, double Angle) RadialPlacementAt(Vector point, double minimum)
-        {
-            var dx = point.X - Center.X;
-            var dy = point.Y - Center.Y;
-            var distance = System.Math.Sqrt(dx * dx + dy * dy);
-            var angle = distance > 0 ? System.Math.Atan2(dy, dx) : Angle;
-            if (Arc != null && Kind == DimensionKind.Radius)
-                angle = DimensionBuilder.ClampToSweep(Arc, angle);
-
-            var offset = distance - Radius;
-            if (offset > -minimum && offset < minimum)
-                offset = offset >= 0 ? minimum : -minimum;
-            if (offset < minimum - Radius)
-                offset = minimum - Radius <= -minimum ? minimum - Radius : minimum;
-            return (offset, Math.Angle.NormalizeRad(angle));
-        }
-
-        /// <summary>
-        /// Where an extension line leaving <paramref name="foot"/> on the dimension line first
-        /// meets the profile offset by <paramref name="clearance"/>, walking toward the part by the
-        /// distance known to be free at each step. <paramref name="foot"/> itself when it is
-        /// already that close.
-        /// </summary>
-        public Vector ExtensionTip(Vector foot, double clearance)
-        {
-            var horizontal = Kind == DimensionKind.OverallHorizontal;
-            var position = horizontal ? foot.Y : foot.X;
-            var center = horizontal
-                ? (Extents.Bottom + Extents.Top) / 2
-                : (Extents.Left + Extents.Right) / 2;
-            var sign = System.Math.Sign(center - position);
-            var direction = horizontal ? new Vector(0, sign) : new Vector(sign, 0);
-
-            // The walk ends at the far side of the part at the latest: the line touches the part.
-            var limit = System.Math.Abs(center - position) + (horizontal ? Extents.Width : Extents.Length) / 2;
-            var travelled = 0.0;
-            for (var i = 0; i < MaxExtensionSteps && travelled < limit; i++)
-            {
-                var free = DistanceToProfile(foot + direction * travelled) - clearance;
-                if (free <= clearance * ExtensionPrecision)
-                    break;
-                travelled += free;
-            }
-            return foot + direction * System.Math.Min(travelled, limit);
-        }
-
-        private double DistanceToProfile(Vector point)
-        {
-            var nearest = double.MaxValue;
-            foreach (var entity in Profile)
-                nearest = System.Math.Min(nearest, point.DistanceTo(entity.ClosestPointTo(point)));
-            return nearest;
-        }
-
-        /// <summary>
-        /// The offset that puts the dimension line through <paramref name="point"/>, on the side of
-        /// the part's center the point is on and at least <paramref name="minimum"/> clear of it.
-        /// </summary>
-        public double OffsetAt(Vector point, double minimum)
-        {
-            var horizontal = Kind == DimensionKind.OverallHorizontal;
-            var position = horizontal ? point.Y : point.X;
-            var low = horizontal ? Extents.Bottom : Extents.Left;
-            var high = horizontal ? Extents.Top : Extents.Right;
-
-            return position >= (low + high) / 2
-                ? System.Math.Max(minimum, position - high)
-                : System.Math.Min(-minimum, position - low);
-        }
-    }
-}

OpenNest.Core/Dimensions/DrawingDimension.cs

@@ -1,48 +0,0 @@
-using System;
-
-namespace OpenNest.Dimensions
-{
-    public enum DimensionKind
-    {
-        /// <summary>The part's overall size along X, drawn above or below it.</summary>
-        OverallHorizontal,
-
-        /// <summary>The part's overall size along Y, drawn right or left of it.</summary>
-        OverallVertical,
-
-        /// <summary>A circle's or arc's radius, on a leader from its center.</summary>
-        Radius,
-
-        /// <summary>A circle's or arc's diameter, on a leader across it.</summary>
-        Diameter,
-    }
-
-    /// <summary>
-    /// An annotation on a drawing. Only its placement is stored: the value is measured from the
-    /// geometry each time it is resolved, so it cannot go stale. It never affects the program.
-    /// </summary>
-    public sealed class DrawingDimension
-    {
-        public DimensionKind Kind { get; set; }
-
-        /// <summary>
-        /// Never zero. Overall dimensions: distance from the part's extents to the dimension line,
-        /// positive above a horizontal dimension's part or right of a vertical one's. Radius and
-        /// diameter: distance from the curve to the label along the leader, positive outside.
-        /// </summary>
-        public double Offset { get; set; }
-
-        /// <summary>The circle or arc a radius or diameter measures; empty for overall dimensions.</summary>
-        public Guid EntityId { get; set; }
-
-        /// <summary>Radius and diameter: the leader's direction from the center, in radians.</summary>
-        public double Angle { get; set; }
-
-        public bool IsRadial => IsRadialKind(Kind);
-
-        public static bool IsRadialKind(DimensionKind kind) =>
-            kind is DimensionKind.Radius or DimensionKind.Diameter;
-
-        public DrawingDimension Clone() => new() { Kind = Kind, Offset = Offset, EntityId = EntityId, Angle = Angle };
-    }
-}

OpenNest.Core/Dimensions/HoleTable.cs

@@ -1,133 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Converters;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest.Dimensions
-{
-    /// <summary>One hole diameter in a <see cref="HoleTable"/> and every hole cut at that size.</summary>
-    public sealed class HoleSize
-    {
-        public HoleSize(double diameter, bool isKeyed, IReadOnlyList<Vector> centers, IReadOnlyList<Guid> entityIds)
-        {
-            Diameter = diameter;
-            IsKeyed = isKeyed;
-            Centers = centers;
-            EntityIds = entityIds;
-        }
-
-        /// <summary>The diameter, rounded to <see cref="HoleTable.Decimals"/> places.</summary>
-        public double Diameter { get; }
-
-        /// <summary>True when the holes are round except for a keyway, flat or other interruption.</summary>
-        public bool IsKeyed { get; }
-
-        public int Quantity => Centers.Count;
-
-        public IReadOnlyList<Vector> Centers { get; }
-
-        /// <summary>The IDs of every entity that makes up a hole of this size.</summary>
-        public IReadOnlyList<Guid> EntityIds { get; }
-
-        public string DiameterText => "\u00D8" + Diameter.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture)
-            + (IsKeyed ? " keyed" : "");
-    }
-
-    /// <summary>
-    /// Counts the round and keyed holes in a drawing by diameter. A round hole is a cut circle, or a
-    /// closed contour made only of arcs on one center and radius; a keyed hole is a closed contour
-    /// around its center with at least <see cref="MinKeyedSweep"/> of arc on one center and radius,
-    /// and anything else for the rest. Either must lie inside another cut contour, so the outline of
-    /// a round part is not a hole. Marks (scribe, etch, rapids, break cuts) are not holes. Pass the
-    /// entities as they will be cut (visible, with roles applied).
-    /// </summary>
-    public static class HoleTable
-    {
-        /// <summary>Holes whose diameters agree to this many decimal places share a row.</summary>
-        public const int Decimals = 4;
-
-        /// <summary>The least arc, in radians, that makes a contour a keyed hole: 270 degrees.</summary>
-        public const double MinKeyedSweep = 1.5 * System.Math.PI;
-
-        private const double SweepTolerance = 1e-6;
-
-        public static IReadOnlyList<HoleSize> Build(IEnumerable<Entity> entities)
-        {
-            var cut = entities
-                .Where(e => SpecialLayers.IsMaterial(e.Layer) && !ScribeLayerRepair.IsMarkLayer(e.Layer))
-                .ToList();
-            if (cut.Count == 0)
-                return Array.Empty<HoleSize>();
-
-            var shapes = ShapeBuilder.GetShapes(cut);
-            var holes = new List<(double Diameter, bool Keyed, Vector Center, List<Guid> Ids)>();
-            foreach (var shape in shapes)
-            {
-                if (!TryRound(shape, out var center, out var radius, out var keyed))
-                    continue;
-                var box = shape.BoundingBox;
-                var area = box.Area();
-                if (!shapes.Any(other => !ReferenceEquals(other, shape)
-                        && other.BoundingBox.Area() > area + Tolerance.Epsilon
-                        && other.BoundingBox.Contains(box)))
-                    continue;
-                holes.Add((System.Math.Round(radius * 2, Decimals), keyed, center, shape.Entities.Select(e => e.Id).ToList()));
-            }
-
-            return holes
-                .GroupBy(h => (h.Diameter, h.Keyed))
-                .OrderBy(g => g.Key.Diameter)
-                .ThenBy(g => g.Key.Keyed)
-                .Select(g => new HoleSize(
-                    g.Key.Diameter,
-                    g.Key.Keyed,
-                    g.Select(h => h.Center).ToList(),
-                    g.SelectMany(h => h.Ids).ToList()))
-                .ToList();
-        }
-
-        private static bool TryRound(Shape shape, out Vector center, out double radius, out bool keyed)
-        {
-            center = default;
-            radius = 0;
-            keyed = false;
-            if (shape.Entities.Count == 1 && shape.Entities[0] is Circle circle)
-            {
-                center = circle.Center;
-                radius = circle.Radius;
-                return radius > 0;
-            }
-
-            if (!shape.IsClosed())
-                return false;
-
-            var arcs = shape.Entities.OfType<Arc>().ToList();
-            var tolerance = Tolerance.ChainTolerance;
-            var sweep = 0.0;
-            foreach (var arc in arcs)
-            {
-                var total = arcs
-                    .Where(a => a.Center.DistanceTo(arc.Center) <= tolerance
-                        && System.Math.Abs(a.Radius - arc.Radius) <= tolerance)
-                    .Sum(a => a.SweepAngle());
-                if (total <= sweep)
-                    continue;
-                sweep = total;
-                center = arc.Center;
-                radius = arc.Radius;
-            }
-
-            if (radius <= 0 || sweep > Angle.TwoPI + SweepTolerance)
-                return false;
-
-            if (System.Math.Abs(sweep - Angle.TwoPI) <= SweepTolerance && arcs.Count == shape.Entities.Count)
-                return true;
-
-            // The center test turns away a curved slot, whose long arcs wrap around solid material.
-            keyed = true;
-            return sweep >= MinKeyedSweep - SweepTolerance && shape.ToPolygon().ContainsPoint(center);
-        }
-    }
-}