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

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

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

.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'

.github/workflows/windows-release.yml

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

.gitignore

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

@@ -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,11 +37,9 @@ 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` (in Database mode, the server's shared copy once it holds one). Posts live in `Posts/OpenNest.Posts.<Name>/` and deploy to the desktop output's `Posts/` directory. Desktop nest edits go through `BeginChange`/`RecordChange`; see [undo and redo](docs/undo-redo.md).
-- `OpenNest.Desktop` (net8.0): toolkit-neutral desktop logic shared by the WinForms app and `OpenNest.Avalonia`, the cross-platform desktop in progress. It must not reference WinForms/WindowsDesktop, `System.Drawing.Common` or Avalonia (`OpenNest.Desktop.Tests` guards this, including transitive packages); put toolkit-specific rendering, dialogs and settings behind adapters in the front ends.
+- `OpenNest.Console`, `OpenNest.Mcp`, `OpenNest.Api`: front ends; `OpenNest.Benchmark`: whole-job engine comparisons; `OpenNest.Gpu`: GPU evaluators; `OpenNest.Training`: ML data collection. Benchmark timing comparisons require `--parallel 1`; validate layouts and fulfillment, not just elapsed time.
-- `OpenNest.Server`: nest storage HTTP service, kept off Engine and IO. `OpenNest.Server.Worker`: the server nesting worker, shipped in the same image.
-- `OpenNest.Console`, `OpenNest.Mcp`, `OpenNest.Api`: front ends; `OpenNest.Benchmark`: whole-job engine comparisons; `OpenNest.Gpu`: GPU evaluators; `OpenNest.Training`: ML data collection and the Python sketch-search prototype (`sketch-search/README.md`). Benchmark timing comparisons require `--parallel 1`; validate layouts and fulfillment, not just elapsed time.
 
 ## Geometry and ownership safeguards
 
@@ -54,35 +48,28 @@ Releases: follow [the release procedure](docs/releasing.md) and `scripts/Publish
 - `FillLinear` geometry caches are per public call, keyed by `Program` reference identity; never share them across calls/threads. `PartOverlapChecker` is per check; parts/programs must not mutate during its lifetime.
 - `FillScore` ranks count, utilization, compactness; exact ties keep the current layout. Custom comparers remain authoritative. Preserve extents' negative/nonfinite-input fallback, pair preparation and adjusted-column overlap checks. Do not remove bounds recomputations without threshold/rounding characterization.
 - `ObservableList` events own drawing/plate quantity tracking; avoid double accounting. Cutoff parts are excluded from quantity, utilization and overlap checks.
-- `Plate.Outline`/`NestPlateStock.Outline` (`SheetOutline`) make a sheet irregular; `Size` stays its bounding box. Only Irregular fills it (`PackBoundary` eroded by the largest edge spacing); every other engine and fill strategy must place nothing on it, validation must reject parts outside it or over its obstacles, and automatic cut-offs refuse it. See [irregular stock](docs/irregular-stock.md).
 - Cutoffs persist as definitions on `Plate.CutOffs`; apply through `RegenerateCutOffs`, never preview parts. Preserve sequence positions. Batch planning must finish before mutation and roll back on failure. Use `PlateSequencing.Apply` for automatic cutoff dependencies, with nominal spans/reference identity rather than trimmed geometry/names.
 - A cutoff starts only at the origin-side edge: stock can be oversize, so the far edge is unknown. Only a head-locked overcut (`CutOff.HeadLockOvercut`, `HeadHeightLock` markers) may start its far-edge segment there; posts refuse it without lock codes.
 - Fixed emissions (locked programs, drawing-pinned contours) are accepted as given: their violations warn on an UNVERIFIED proposal and never steer the search, while every planner-chosen motion stays strict. Plates without them must keep the `PlanningCharacterizationTests` digests.
-- A `HeadRaise` marker (a rapid made head-up over cut parts) is the safest-route fallback's last resort, added only after the strict search fails; the strict search never marks a rapid. The one designed raise is the rapid out of a cutout's slug after its lead-out, marked at emission (see the cutting planner doc); no lead-out or an overcut keeps the head down. Every post must raise before a marked rapid or refuse the nest.
 - An empty diagnostic is not a clear result unless `IsComplete`. Posting must run checks before writing CNC output; warnings require explicit per-attempt consent, never a persisted bypass. Keep inputs stable through analysis/cancellation.
 - Preserve symbolic G-code variable definitions/references in file round trips. Keep training bitmaps by default; inference checks predictor availability before scalar-only extraction.
 
 Read the relevant contract before changing its behavior:
 
 - [Nest file format](docs/nest-file-format.md)
-- [SVG import and export](docs/svg-import-export.md): SVG numbers are not drawing units; import never guesses a scale
-- [Irregular stock](docs/irregular-stock.md): outlined sheets, what honors the outline and what refuses it
 - [Directional slides](docs/geometry/directional-slides.md) and [pair-spacing limits](docs/geometry/pair-spacing.md)
-- [Lead-in placement](docs/geometry/lead-in-placement.md) (including the planner's eroded pierce for cutouts too small for their lead-in and the stop at a feature's center line) and [pierce zones](docs/geometry/pierce-zone.md): opt-in `PierceDiameter` clearance, the hole pole fallback and the planner's perimeter scrap fallback
+- [Lead-in placement](docs/geometry/lead-in-placement.md) (including the planner's eroded pierce for cutouts too small for their lead-in) and [pierce zones](docs/geometry/pierce-zone.md): opt-in `PierceDiameter` clearance, the hole pole fallback and the planner's perimeter scrap fallback
 - [Breakoffs](docs/breakoffs.md): tabbed scrap; `Break`-layer open cuts that are cut but are not material
 - [Tabbed cutouts](docs/tabbed-cutouts.md): holes cut in pieces around `Tab`-layer spans that are material but never cut; nesting reads material through `NestingMaterial.ForNesting`, so nothing nests in them
-- [Dimensions](docs/dimensions.md): CAD Converter annotations that store placement only, are measured from the cut geometry when shown and never affect the program
-- [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
+- [Machine cutting defaults](docs/machine-cutting-defaults.md): the nest's machine supplies leads, kerf and cut-off settings for plates without their own parameters
 - [Shared settings](docs/shared-settings.md): in Database mode machines, post settings, clamps and nest defaults come from the server once it holds them; offline uses the last copy read, read-only
-- [Server nesting](docs/server-nesting.md): Database-mode Auto Nest queued to the server's worker container (`OPENNEST_ROLE=worker`), one job at a time with no time limit, streaming progress and the best plan so far over SSE; the desktop replays the recorded engine answers to validate and bind locally. My Server Jobs reopens results in later sessions, and each result is kept at most once (`If-Match` Keep). The HTTP server stays off Engine/IO
 - [Cut-time estimates](docs/cut-time-estimates.md): simulator/Calculate Cut Time acceleration planner and placeholder machine limits
 - [Cincinnati CL](docs/cincinnati-post-output.md) and [CI Fiber](docs/cincinnati-ci-fiber-post-output.md)
 - [Fill verification](docs/performance/fill-verification.md): opt-in benchmarks, frozen oracles, Debug-only counters and predictor initialization. Zero Release counters do not prove work removal.
-- [Desktop auto-update](docs/auto-update.md): GitHub Releases by default, opt-in rolling `dev-build` pre-release from green master pushes, the nest server's `/updates` mirror first in Database mode (GitHub fallback), `UpdateFeedUrl` for a self-hosted feed, release Velopack assets and `Deploy-OpenNest.ps1`.
+- [Desktop auto-update](docs/auto-update.md): GitHub Releases by default, `UpdateFeedUrl` for a self-hosted feed, release Velopack assets and `Deploy-OpenNest.ps1`.
 - [Undo and Redo](docs/undo-redo.md): whole-nest history, the recording rule, what a restore rebuilds and what is excluded.
-- [Desktop help](docs/desktop-help.md): WebView2 help window, topic IDs and the pinned help release both packaging scripts install.
+- [Desktop help](docs/desktop-help.md): WebView2 help window, F1 topic IDs and the pinned help release both packaging scripts install.

OpenNest.Api/NestJobPackage.cs

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

OpenNest.Api/NestRequestPart.cs

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

OpenNest.Avalonia/App.axaml.cs

@@ -17,10 +17,7 @@ namespace OpenNest.Avalonia
                 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).
+                // --snapshot <png> [plate]: render the window to an image and exit, for checking the drawing.
-                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],

OpenNest.Avalonia/MainWindow.axaml

@@ -8,13 +8,10 @@
   <DockPanel>
     <Menu DockPanel.Dock="Top">
       <MenuItem Header="_File">
-        <MenuItem x:Name="OpenMenuItem" Header="_Open..." InputGesture="Ctrl+O" Click="OnOpen" />
+        <MenuItem 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" />
@@ -24,11 +21,10 @@
 
     <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="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>
 

OpenNest.Avalonia/MainWindow.axaml.cs

@@ -1,16 +1,10 @@
 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
@@ -19,22 +13,12 @@ namespace OpenNest.Avalonia
 
     public partial class MainWindow : Window
     {
-        private Document document;
+        private Nest nest;
         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
             {
@@ -47,11 +31,9 @@ namespace OpenNest.Avalonia
 
         public void OpenNest(string path)
         {
-            if (nesting != null)
-                return;
             try
             {
-                document = new Document { Nest = new NestReader(path).Read() };
+                nest = new NestReader(path).Read();
             }
             catch (Exception ex)
             {
@@ -61,44 +43,30 @@ namespace OpenNest.Avalonia
 
             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;
+            PlateList.SelectedIndex = nest.Plates.Count > 0 ? 0 : -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",
@@ -112,88 +80,6 @@ namespace OpenNest.Avalonia
 
         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);
@@ -234,8 +120,6 @@ namespace OpenNest.Avalonia
             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;
         }
 

OpenNest.Avalonia/OpenNest.Avalonia.csproj

@@ -11,7 +11,6 @@
   <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" />

OpenNest.Benchmark/BenchmarkJob.cs

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

OpenNest.Benchmark/BenchmarkRunner.cs

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

OpenNest.Benchmark/CommonLineSetting.cs

@@ -1,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/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)
@@ -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)
     {
@@ -1013,17 +937,6 @@ static class NestConsole
             return false;
         }
 
-        // A common line cut once needs a post that writes it; none falls back to cutting it twice.
-        try
-        {
-            OpenNest.CNC.CommonLineCuts.EnsurePostable(nest, post);
-        }
-        catch (InvalidOperationException ex)
-        {
-            Console.Error.WriteLine($"Error: {ex.Message} No output was written.");
-            return false;
-        }
-
         var verification = PostVerificationAnalyzer.AnalyzeForPost(nest, post);
         Console.WriteLine(verification.ToDisplayText());
         if (!verification.CanPost(options.AcknowledgePostRisks))
@@ -1068,7 +981,7 @@ static class NestConsole
             Usage: OpenNest.Console <input-files...> [options]
 
             Arguments:
-              input-files            One or more .nest nest files or .dxf/.dwg/.svg drawing files
+              input-files            One or more .nest nest files or .dxf/.dwg drawing files
 
             Modes:
               <nest.nest>             Load nest and fill (existing behavior)
@@ -1077,19 +990,12 @@ static class NestConsole
 
             Options:
               --repair-bends-mm <n>   Opt-in endpoint/tick repair, limit >0.001 to 3.175 physical mm
-              --cad-units inches|mm  Explicit source coordinate units required for bend repair;
+              --cad-units inches|mm  Explicit source coordinate units required for bend repair
-                                     also the units SVGs import in (default inches)
-              --svg-units-per-inch N SVG units per inch, for a file without a real-world size
               --drawing <name>       Drawing name to fill with (default: first drawing)
               --plate <index>        Plate index to fill (default: 0)
-              --quantity <n>          Max parts to place (default: 0 = unlimited). With --autonest: copies of
+              --quantity <n>          Max parts to place (default: 0 = unlimited)
-                                     each drawing (default: its required quantity less copies on other
-                                     plates; one of each when no drawing has a required quantity)
               --spacing <value>      Override part spacing
               --size <WxL>           Override plate size (e.g. 60x120); required for DXF-only mode
-              --outline <dxf>        Make the plate an irregular sheet: the file's largest closed contour is
-                                     the sheet, other closed contours are obstacles; sets the size. Only
-                                     --autonest with the Irregular (or Default) engine nests on it
               --output <path>        Output nest file path (default: <input>-result.nest)
               --template <path>      Nest template for plate defaults (thickness, quadrant, material, spacing)
               --autonest             Validated whole-job nesting (one sheet unless --max-sheets); replaces only after acceptance
@@ -1098,10 +1004,8 @@ static class NestConsole
               --stock <WxL[:cost],...>  With --autonest: sheet sizes to offer, each unlimited (default: the
                                      target plate's size); spacing, quadrant and clamps follow the target
               --allow-invalid        Explicitly keep representable invalid autonest layouts (default: reject, exit 2)
-              --engine <name>        With --autonest: jobs engine (default: Default; also Irregular,
+              --engine <name>        With --autonest: jobs engine (default: Default; also Irregular, Rectangles, Fill, ...).
-                                     Rectangles, Lattice, ...). Without --autonest: fill strategy
+                                     Without --autonest: fill strategy (Fill (default), Strip, Vertical Remnant, Horizontal Remnant)
-                                     (Lattice (default), Strip, Vertical Remnant,
-                                     Horizontal Remnant)
               --keep-parts           Don't clear existing parts before filling
               --no-fill              Keep the loaded .nest as it is (no fill); plan, save or post it
               --plan-cutting         After filling (or loading with --no-fill), plan cutting (part order,
@@ -1133,7 +1037,6 @@ static class NestConsole
         public int Quantity;
         public double? Spacing;
         public Size? PlateSize;
-        public string OutlineFile;
         public bool CheckOverlaps;
         public bool NoSave;
         public bool KeepParts;
@@ -1156,6 +1059,5 @@ static class NestConsole
         public bool AllPlates;
         public double? RepairBendsMillimeters;
         public BendRepairUnits CadUnits;
-        public double? SvgUnitsPerInch;
     }
 }

OpenNest.Core/AutomaticCutOffPlanner.cs

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

OpenNest.Core/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

@@ -379,7 +379,7 @@ namespace OpenNest.CNC
                 {
                     // Cutting strategies emit contour moves on Display; the posts cut them.
                     LayerType.Cut or LayerType.Display or LayerType.Leadin or LayerType.Leadout or LayerType.Break
-                        or LayerType.CommonLine => CutSimulationStepKind.Cut,
+                        => CutSimulationStepKind.Cut,
                     LayerType.Scribe => CutSimulationStepKind.Scribe,
                     _ => null, // Tab spans are never cut.
                 };

OpenNest.Core/CNC/CuttingPlanning/ContourEntryCandidate.cs

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

OpenNest.Core/CNC/CuttingPlanning/ContourEntryRanking.cs

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

OpenNest.Core/CNC/CuttingPlanning/CuttingPlanCommit.cs

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

OpenNest.Core/CNC/CuttingPlanning/ExecutionMotionReader.cs

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

OpenNest.Core/CNC/CuttingPlanning/IncrementalClosureDrift.cs

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

OpenNest.Core/CNC/CuttingPlanning/LeadMaterialSnapshot.cs

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

OpenNest.Core/CNC/CuttingPlanning/LeadPathValidator.cs

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

OpenNest.Core/CNC/CuttingPlanning/NestedPartContainment.cs

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

OpenNest.Core/CNC/CuttingPlanning/NestedPartReview.cs

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

OpenNest.Core/CNC/CuttingPlanning/OwnedCuttingParameters.cs

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

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

OpenNest.Core/CNC/CuttingPlanning/PreparedContours.cs

@@ -24,16 +24,6 @@ public sealed record ContourChoice(int ContourOrdinal, int EntityOrdinal, Vector
     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,8 +39,6 @@ public sealed class PreparedContours
     // Closed cutouts with tab spans, in program order. Like break cuts they are not choices:
     // every full or prefix emission cuts their pieces after the break cuts.
     private readonly List<Shape> tabbedCutouts;
-    // 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;
@@ -65,10 +53,6 @@ public sealed class PreparedContours
     // never-executed DisplayPerimeterTail. Null for an ordinary cut perimeter.
     private readonly Shape displayOutline;
     private bool hasCutPerimeter => displayOutline == null;
-    // Set for a common-line member: 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)
@@ -77,12 +61,9 @@ public sealed class PreparedContours
     }
 
     private PreparedContours(Shape[] shapes, List<Entity> scribes, List<Shape> breakCuts, List<Shape> tabbedCutouts,
-        CuttingParameters parameters, Shape displayOutline, PierceZoneMemo pierceZones = null,
+        CuttingParameters parameters, Shape displayOutline)
-        CommonLinePerimeter commonLine = null)
     {
-        this.pierceZones = pierceZones ?? new PierceZoneMemo();
         this.displayOutline = displayOutline;
-        this.commonLine = commonLine;
         this.shapes = shapes;
         this.scribes = scribes;
         this.breakCuts = breakCuts;
@@ -90,19 +71,11 @@ 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,
-            unpinned.displayOutline, unpinned.pierceZones, unpinned.commonLine)
+            unpinned.displayOutline)
     {
         contourParameters = new CuttingParameters[shapes.Length];
         var rejected = new List<CutPinResolution>();
@@ -119,9 +92,8 @@ public sealed class PreparedContours
                 throw new ArgumentException("A pin resolution does not belong to these contours.", nameof(pins));
             if (pinned[contour] != null)
                 throw new ArgumentException("Two pins resolve to one contour.", nameof(pins));
-            // The emitter tabs only the outside, so a tab elsewhere cannot be cut as pinned. A
+            // The emitter tabs only the outside, so a tab elsewhere cannot be cut as pinned.
-            // common-line member's outside is cut from its shared spans, never from a pin.
+            if (pin.Pin.HasTab && contour != PerimeterOrdinal)
-            if (pin.Pin.HasTab && contour != PerimeterOrdinal || commonLine != null && contour == PerimeterOrdinal)
             {
                 rejected.Add(pin);
                 continue;
@@ -141,7 +113,7 @@ public sealed class PreparedContours
     // a pinned perimeter keeps its pin's settings: the analysis is only kept for review.
     private PreparedContours(PreparedContours source, PartSupport support, Vector location, Tab tab)
         : this(source.shapes, source.scribes, source.breakCuts, source.tabbedCutouts, source.parameters,
-            source.displayOutline, source.pierceZones, source.commonLine)
+            source.displayOutline)
     {
         for (var contour = 0; contour < Count; contour++)
         {
@@ -180,8 +152,6 @@ public sealed class PreparedContours
             throw new ArgumentException("Support tabs need a complete analysis with a tab point.", nameof(support));
         if (!hasCutPerimeter)
             throw new ArgumentException("A display perimeter is never cut, so it cannot hold a support tab.", nameof(support));
-        if (commonLine != null)
-            throw new ArgumentException("A common-line member is never support-tabbed.", nameof(support));
         return new PreparedContours(this, support, location, tab);
     }
 
@@ -195,24 +165,12 @@ public sealed class PreparedContours
     public Vector SupportOrigin => supportOrigin;
 
     /// <summary>Whether the emitted perimeter is tabbed: by the plate settings, its pin or support.</summary>
-    internal bool PerimeterTabbed => hasCutPerimeter && commonLine == null && ParametersFor(PerimeterOrdinal).TabsEnabled;
+    internal bool PerimeterTabbed => hasCutPerimeter && ParametersFor(PerimeterOrdinal).TabsEnabled;
-
-    /// <summary>
-    /// True for a common-line member (see <see cref="CommonLinePerimeter"/>): its perimeter has one
-    /// fixed entry and is emitted 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();
-
-    /// <summary>The pierce-zone resolutions these contours' emissions share; for tests.</summary>
-    internal PierceZoneMemo PierceZones => pierceZones;
     /// <summary>
     /// The cut perimeter, emitted after every hole; <see cref="Count"/> (no contour) when the outside
     /// is a display perimeter, so every contour below it is a hole.
@@ -222,7 +180,7 @@ public sealed class PreparedContours
     /// <summary>False when the outside is a display perimeter that is never cut: all contours are holes.</summary>
     public bool HasCutPerimeter => hasCutPerimeter;
 
-    /// <summary>Resolved pins this preparation could not honor: a tab on an internal contour.</summary>
+    /// <summary>Resolved pins this preparation could not honour: a tab on an internal contour.</summary>
     public IReadOnlyList<CutPinResolution> RejectedPins { get; } = Array.Empty<CutPinResolution>();
 
     /// <summary>True when a drawing pin fixes this contour's entry, leads and tab.</summary>
@@ -245,10 +203,10 @@ public sealed class PreparedContours
     /// contour keeps the automatic selection with <paramref name="parameters"/>.
     /// </summary>
     public static PreparedContours Capture(Program program, CuttingParameters parameters,
-        IReadOnlyList<CutPinResolution> pins, CancellationToken token = default, CommonLinePerimeter commonLine = null)
+        IReadOnlyList<CutPinResolution> pins, CancellationToken token = default)
     {
         ArgumentNullException.ThrowIfNull(pins);
-        var unpinned = Capture(program, parameters, token, commonLine);
+        var unpinned = Capture(program, parameters, token);
         return pins.Any(p => p?.IsResolved != false) ? new PreparedContours(unpinned, pins, token) : unpinned;
     }
 
@@ -270,11 +228,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);
@@ -337,40 +291,6 @@ public sealed class PreparedContours
             if (NominalContourClosure.IsClosed(Start(current.Entities[0]), End(entity)))
                 FinishContour();
         }
-        if (commonLine != null)
-        {
-            if (displayPerimeter != null || current.Entities.Count != 0)
-                throw new ArgumentException("A common-line member needs one closed cut perimeter.");
-            if (!double.IsFinite(commonLine.Kerf) || commonLine.Kerf <= 0 || commonLine.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)
@@ -440,8 +360,6 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return pin;
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return fixedEntry;
         var point = shape.ClosestPointTo(approach, out var entity);
         return Entry(contourOrdinal, shape.Entities.IndexOf(entity), point);
     }
@@ -460,8 +378,6 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return new[] { pin };
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return new[] { fixedEntry };
         var entries = new List<ContourChoice>();
         entries.Add(ClosestEntry(contourOrdinal, approach));
         for (var i = 0; i < shape.Entities.Count && entries.Count < maxEntries; i++)
@@ -549,9 +465,7 @@ public sealed class PreparedContours
         if (contourOrdinal == PerimeterOrdinal || pinned[contourOrdinal] != null)
             return Array.Empty<ContourChoice>();
         targets = targets.Where(t => t.Owner == this && t.ContourOrdinal == contourOrdinal).Take(max).ToArray();
-        var depth = System.Math.Max(ParametersFor(contourOrdinal).GetEffectivePierceClearance(),
+        var found = ErodedPierce.Find(shape, ParametersFor(contourOrdinal).GetEffectivePierceClearance(),
-            ApplicableLeadInLength(contourOrdinal));
-        var found = ErodedPierce.Find(shape, depth,
             targets.Select(t => t.Point).ToArray(), max);
         var entries = new List<ContourChoice>();
         for (var i = 0; i < found.Pierces.Count; i++)
@@ -596,7 +510,7 @@ public sealed class PreparedContours
     }
 
     /// <summary>
-    /// The uncapped preferred automatic start catalog for one contour, in preference then
+    /// The uncapped preferred automatic start catalogue for one contour, in preference then
     /// contour-travel order: convex corners of the contour's own winding, then straight-edge
     /// midpoints, then tangent line/arc joints. Reflex and cusp vertices, collinear
     /// line/line splits, circles and interior points never appear; each geometric point is
@@ -611,15 +525,13 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return new[] { new ContourEntryCandidate(pin, AutomaticEntryKind.Pinned) };
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return new[] { new ContourEntryCandidate(fixedEntry, AutomaticEntryKind.Pinned) };
         if (IsSingleCircle(shape))
-            throw new ArgumentException("Circles have no preferred corners or joints; use the fallback catalog.");
+            throw new ArgumentException("Circles have no preferred corners or joints; use the fallback catalogue.");
         return SupportFiltered(contourOrdinal, PreferredCandidates(shape, contourOrdinal, token), SupportEntries.Steadying);
     }
 
     /// <summary>
-    /// The complete uncapped automatic start catalog: the preferred points of
+    /// The complete uncapped automatic start catalogue: the preferred points of
     /// <see cref="AutomaticEntryCandidates"/> followed by tier-3 fallbacks — native arc
     /// midpoints, near-convex-corner points on straight edges, the eight compass points of a
     /// whole circle, and the exact target-facing closest point toward
@@ -627,7 +539,7 @@ public sealed class PreparedContours
     /// A pure-circle contour therefore yields compass points instead of refusing. Every
     /// fallback passes the same reflex/cusp exclusion and geometric duplicate merge as the
     /// preferred tier; fallbacks never replace a preferred point at the same geometry. A
-    /// pinned contour's catalog is its pinned entry alone: nothing may relocate it.
+    /// pinned contour's catalogue is its pinned entry alone: nothing may relocate it.
     /// </summary>
     internal IReadOnlyList<ContourEntryCandidate> AutomaticEntryCandidatesWithFallbacks(
         int contourOrdinal,
@@ -639,8 +551,6 @@ public sealed class PreparedContours
         var shape = GetShape(contourOrdinal);
         if (pinned[contourOrdinal] is { } pin)
             return new[] { new ContourEntryCandidate(pin, AutomaticEntryKind.Pinned) };
-        if (FixedCommonLineEntry(contourOrdinal) is { } fixedEntry)
-            return new[] { new ContourEntryCandidate(fixedEntry, AutomaticEntryKind.Pinned) };
         var all = IsSingleCircle(shape)
             ? new List<ContourEntryCandidate>()
             : PreferredCandidates(shape, contourOrdinal, token);
@@ -650,7 +560,7 @@ public sealed class PreparedContours
 
     /// <summary>
     /// Whether this preparation tabs its perimeter for support (see <see cref="WithSupportTab"/>):
-    /// its automatic catalog then keeps to steadying points unless asked for a fallback.
+    /// its automatic catalogue then keeps to steadying points unless asked for a fallback.
     /// </summary>
     internal bool HasSupportTab => support != null && !IsPinned(PerimeterOrdinal);
 
@@ -691,8 +601,8 @@ public sealed class PreparedContours
 
     /// <summary>Preferred tier: convex corners, straight midpoints, tangent joints.</summary>
     private List<ContourEntryCandidate> PreferredCandidates(Shape shape, int contourOrdinal, CancellationToken token)
-        => CatalogPoints(shape, token)
+        => CataloguePoints(shape, token)
-            .Select(p => new ContourEntryCandidate(Entry(contourOrdinal, p.EntityOrdinal, p.Point), p.Kind, p.CornerReach))
+            .Select(p => new ContourEntryCandidate(Entry(contourOrdinal, p.EntityOrdinal, p.Point), p.Kind))
             .ToList();
 
     /// <summary>
@@ -737,7 +647,7 @@ public sealed class PreparedContours
         // endpoint and so never lands on the reflex/cusp vertex at the far end.
         if (lead > 0 && !(count == 1 && shape.Entities[0] is Circle))
         {
-            foreach (var corner in CatalogPoints(shape, token)
+            foreach (var corner in CataloguePoints(shape, token)
                          .Where(p => p.Kind == AutomaticEntryKind.ConvexCorner))
             {
                 token.ThrowIfCancellationRequested();
@@ -851,16 +761,14 @@ public sealed class PreparedContours
         };
 
     /// <summary>
-    /// The preferred catalog points for one contour: for each entity, its convex corner
+    /// The preferred catalogue points for one contour: for each entity, its convex corner
     /// (end vertex, classified from the contour's own winding) and its straight-edge midpoint,
-    /// plus tangent line/arc joints. The joints of a corner fillet (see <see cref="FilletReach"/>)
+    /// plus tangent line/arc joints. Reflex, cusp and collinear-split vertices contribute
-    /// are that corner's convex corners. Reflex, cusp and collinear-split vertices contribute
     /// nothing; a single whole circle yields no points at all.
     /// </summary>
-    private List<(int EntityOrdinal, Vector Point, AutomaticEntryKind Kind, double CornerReach)> CatalogPoints(
+    private List<(int EntityOrdinal, Vector Point, AutomaticEntryKind Kind)> CataloguePoints(Shape shape, CancellationToken token)
-        Shape shape, CancellationToken token)
     {
-        var found = new List<(int, Vector, AutomaticEntryKind, double)>();
+        var found = new List<(int, Vector, AutomaticEntryKind)>();
         var count = shape.Entities.Count;
         if (count == 1 && shape.Entities[0] is Circle)
         {
@@ -875,7 +783,7 @@ public sealed class PreparedContours
             token.ThrowIfCancellationRequested();
             var entity = shape.Entities[i];
 
-            // Vertex reached by traveling along entity i (its end point), reported under
+            // Vertex reached by travelling along entity i (its end point), reported under
             // entity i. The closed contour guarantees every vertex appears exactly once
             // this way; each is classified from the contour's own winding.
             var vertex = End(entity);
@@ -884,65 +792,29 @@ public sealed class PreparedContours
                 switch (corner.Kind)
                 {
                     case ContourCuttingStrategy.CornerKind.Convex:
-                        found.Add((i, vertex, AutomaticEntryKind.ConvexCorner, 0));
+                        found.Add((i, vertex, AutomaticEntryKind.ConvexCorner));
                         break;
                     case ContourCuttingStrategy.CornerKind.Smooth
                         when entity is Line && Next(i) is Arc:
                         // A line leaving into an arc: the tangent joint. The reverse travel
                         // order classifies the same joint from the arc, matched below.
-                        found.Add(Joint(i, vertex, (i + 1) % count));
+                        found.Add((i, vertex, AutomaticEntryKind.TangentJoint));
                         break;
                     // Reflex, cusp, collinear splits (smooth line→line) and arc→line joins
                     // of a plain straight edge are not preferred automatic starts here.
                     case ContourCuttingStrategy.CornerKind.Smooth
                         when entity is Arc && Next(i) is Line:
-                        found.Add(Joint(i, vertex, i));
+                        found.Add((i, vertex, AutomaticEntryKind.TangentJoint));
                         break;
                 }
             }
 
             if (entity is Line line)
-                found.Add((i, line.MidPoint, AutomaticEntryKind.StraightMidpoint, 0));
+                found.Add((i, line.MidPoint, AutomaticEntryKind.StraightMidpoint));
         }
         return found;
 
         Entity Next(int index) => shape.Entities[(index + 1) % count];
-
-        (int, Vector, AutomaticEntryKind, double) Joint(int entityOrdinal, Vector vertex, int arcOrdinal) =>
-            FilletReach(shape, arcOrdinal) is { } reach
-                ? (entityOrdinal, vertex, AutomaticEntryKind.ConvexCorner, reach)
-                : (entityOrdinal, vertex, AutomaticEntryKind.TangentJoint, 0);
-    }
-
-    /// <summary>
-    /// How far the joints of the arc at <paramref name="arcOrdinal"/> lie from the sharp corner it
-    /// rounds, when it is a corner fillet: tangent to straight edges at both ends, turning less
-    /// than a half circle the convex way, and reaching back along each edge no further than the
-    /// edge is long. A fillet's joints start the cut at the corner, where the mismatch when the
-    /// cut closes is least seen, instead of on a straight edge. Null for any other arc.
-    /// </summary>
-    private static double? FilletReach(Shape shape, int arcOrdinal)
-    {
-        var count = shape.Entities.Count;
-        if (shape.Entities[arcOrdinal] is not Arc arc
-            || shape.Entities[(arcOrdinal + count - 1) % count] is not Line before
-            || shape.Entities[(arcOrdinal + 1) % count] is not Line after)
-            return null;
-        var sweep = arc.SweepAngle();
-        if (sweep >= System.Math.PI - OpenNest.Math.Tolerance.Epsilon)
-            return null;
-        if (!IsSmooth(before.EndPoint, before) || !IsSmooth(arc.EndPoint(), arc))
-            return null;
-        var winding = ContourCuttingStrategy.DetermineWinding(shape);
-        if (ContourCuttingStrategy.ClassifyTurn((before.EndPoint - before.StartPoint).Normalize(),
-                (after.EndPoint - after.StartPoint).Normalize(), winding) != ContourCuttingStrategy.CornerKind.Convex)
-            return null;
-        var reach = arc.Radius * 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>
@@ -970,8 +842,8 @@ public sealed class PreparedContours
         // reads only the chosen contour and the contour count, so only that contour is cloned.
         var owned = new Shape[shapes.Length];
         owned[choice.ContourOrdinal] = (Shape)shapes[choice.ContourOrdinal].Clone();
-        return new ContourCuttingStrategy { Parameters = parameters, PierceZones = pierceZones }.EmitCandidateIsolated(
+        return new ContourCuttingStrategy { Parameters = parameters }.EmitCandidateIsolated(
-            owned, scribes.Select(e => e.Clone()).ToList(), choice, contourParameters, PerimeterOrdinal, commonLine);
+            owned, scribes.Select(e => e.Clone()).ToList(), choice, contourParameters, PerimeterOrdinal);
     }
 
     // Each prefix is a standalone owned program, including the same scribes and break cuts once.
@@ -983,11 +855,11 @@ public sealed class PreparedContours
 
     // Only a complete emission carries a display perimeter's tail: prefixes are search probes.
     private Program EmitOwned(IReadOnlyList<ContourChoice> choices, bool complete) =>
-        new ContourCuttingStrategy { Parameters = parameters, PierceZones = pierceZones }.EmitPrepared(
+        new ContourCuttingStrategy { Parameters = parameters }.EmitPrepared(
             shapes.Select(s => (Shape)s.Clone()).ToArray(), scribes.Select(e => e.Clone()).ToList(), choices,
             contourParameters, breakCuts.Select(s => (Shape)s.Clone()).ToList(),
             tabbedCutouts.Select(s => (Shape)s.Clone()).ToList(), PerimeterOrdinal,
-            complete ? (Shape)displayOutline?.Clone() : null, commonLine);
+            complete ? (Shape)displayOutline?.Clone() : null);
 
     /// <summary>Open break cuts this preparation cuts before its contours.</summary>
     public int BreakCutCount => breakCuts.Count;
@@ -1007,9 +879,8 @@ public sealed class PreparedContours
     {
         token.ThrowIfCancellationRequested();
         var expected = ExecutionMotionReader.ReadSupported(Emit(choices), location, null, token);
-        // Only the outside is tabbed, with its own pin's tab when it is pinned. A common-line
+        // Only the outside is tabbed, with its own pin's tab when it is pinned.
-        // member's shared spans are accounted as the material's tabs, never as a tab gap.
+        if (!hasCutPerimeter)
-        if (!hasCutPerimeter || commonLine != null)
             return new(this, choices, expected, 0);
         var perimeter = ParametersFor(PerimeterOrdinal);
         return new(this, choices, expected, perimeter.TabsEnabled ? perimeter.TabConfig.Size : 0);
@@ -1042,11 +913,6 @@ public sealed class PreparedContours
         // A pinned contour is cut exactly as pinned: no other entry may be emitted for it.
         if (pinned[choice.ContourOrdinal] is { } pin && pin != choice)
             throw new ArgumentException("A pinned contour keeps its drawing pin's entry.");
-        // A common-line perimeter is cut from its one fixed entry, 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);
@@ -1055,27 +921,24 @@ public sealed class PreparedContours
         }
     }
 
-    private ContourChoice FixedCommonLineEntry(int contourOrdinal) =>
-        commonLineEntry != null && contourOrdinal == PerimeterOrdinal ? commonLineEntry : null;
-
     private Shape GetShape(int ordinal) => ordinal < 0 || ordinal >= Count
         ? throw new ArgumentException("Foreign contour ordinal.") : shapes[ordinal];
 
     /// <summary>
-    /// Representative POINTS per contour ordinal (bounding-box center) for hole routing
+    /// Representative POINTS per contour ordinal (bounding-box centre) for hole routing
     /// only — the S10 <c>CuttingHoleOrder</c> proxy. The perimeter has no entry; it is the
     /// route's fixed endpoint, not a stop. These are ordering proxies, never cut points.
     /// </summary>
-    internal IReadOnlyList<Vector?> HoleCenters(CancellationToken token = default)
+    internal IReadOnlyList<Vector?> HoleCentres(CancellationToken token = default)
     {
         token.ThrowIfCancellationRequested();
-        var centers = new Vector?[Count];
+        var centres = new Vector?[Count];
         for (var contour = 0; contour < PerimeterOrdinal; contour++)
         {
             token.ThrowIfCancellationRequested();
-            centers[contour] = GetShape(contour).BoundingBox.Center;
+            centres[contour] = GetShape(contour).BoundingBox.Center;
         }
-        return centers;
+        return centres;
     }
 
     /// <summary>The bounding box of contour <paramref name="contourOrdinal"/>, local. A routing hint only.</summary>
@@ -1097,7 +960,7 @@ public sealed class PreparedContours
     /// which treat a point within <see cref="OpenNest.Math.Tolerance.Epsilon"/> of an endpoint as that endpoint and
     /// start the contour there. An entry that close to a vertex is that vertex, so the lead-in ends
     /// where the contour starts: otherwise the span between them (5e-8 in on imported arcs whose
-    /// stored center sits beside the chord's midpoint) is never cut.
+    /// stored centre sits beside the chord's midpoint) is never cut.
     /// </summary>
     private static Vector SnapToVertex(Shape shape, int entityOrdinal, Vector point)
     {

OpenNest.Core/CNC/CuttingPlanning/ReleasedContourState.cs

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

OpenNest.Core/CNC/CuttingPlanning/SeamOvercut.cs

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

@@ -90,9 +90,8 @@ internal static class StateFingerprint
             TabSettings(p.TabConfig);
             Flag(p.TabsEnabled);
             Flag(p.SupportTabs);
-            Flag(p.TabBySize);
+            Number(p.NoBedTabMinWidth);
-            Number(p.TabSizeMinWidth);
+            Number(p.NoBedTabMaxWidth);
-            Number(p.TabSizeMaxWidth);
             Number(p.TabHeldMaxLength);
             Sequence(p.Sequencing);
             Assignment(p.Assignment);

OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs

@@ -10,12 +10,6 @@ namespace OpenNest.CNC.CuttingStrategy
     {
         public CuttingParameters Parameters { get; set; }
 
-        /// <summary>
-        /// Remembers pierce-zone resolutions by contour ordinal across the emissions of one
-        /// preparation (see <see cref="PierceZoneMemo"/>); null resolves every emission afresh.
-        /// </summary>
-        internal PierceZoneMemo PierceZones { get; set; }
-
         private record ContourEntry(Shape Shape, Vector Point, Entity Entity);
 
         public CuttingResult Apply(Program partProgram, Vector approachPoint)
@@ -267,16 +261,14 @@ namespace OpenNest.CNC.CuttingStrategy
         internal Program EmitPrepared(Shape[] shapes, List<Entity> scribes,
             IReadOnlyList<CuttingPlanning.ContourChoice> choices,
             IReadOnlyList<CuttingParameters> contourParameters = null, IReadOnlyList<Shape> breakCuts = null,
-            IReadOnlyList<Shape> tabbedCutouts = null, int? perimeterOrdinal = null, Shape displayTail = null,
+            IReadOnlyList<Shape> tabbedCutouts = null, int? perimeterOrdinal = null, Shape displayTail = null)
-            CuttingPlanning.CommonLinePerimeter commonLine = null)
         {
             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, perimeterOrdinal ?? shapes.Length - 1);
-                commonLine);
             if (displayTail != null)
             {
                 // Display only, after every cut: executed reads and posts stop at its marker.
@@ -294,12 +286,11 @@ namespace OpenNest.CNC.CuttingStrategy
         // installed on a Part or accepted as a complete plan.
         internal Program EmitCandidateIsolated(Shape[] shapes, List<Entity> scribes,
             CuttingPlanning.ContourChoice choice, IReadOnlyList<CuttingParameters> contourParameters = null,
-            int? perimeterOrdinal = null, CuttingPlanning.CommonLinePerimeter commonLine = null)
+            int? perimeterOrdinal = null)
         {
             var result = new Program(Mode.Absolute);
             EmitScribeContours(result, scribes);
-            EmitChosenContours(result, shapes, new[] { choice }, contourParameters, perimeterOrdinal ?? shapes.Length - 1,
+            EmitChosenContours(result, shapes, new[] { choice }, contourParameters, perimeterOrdinal ?? shapes.Length - 1);
-                commonLine);
             result.Mode = Mode.Incremental;
             return result;
         }
@@ -310,41 +301,20 @@ namespace OpenNest.CNC.CuttingStrategy
         // prior choices — the differential tests in ContourCandidateEmissionTests pin this.
         private void EmitChosenContours(Program result, Shape[] shapes,
             IReadOnlyList<CuttingPlanning.ContourChoice> choices, IReadOnlyList<CuttingParameters> contourParameters,
-            int perimeterOrdinal, CuttingPlanning.CommonLinePerimeter commonLine = null)
+            int perimeterOrdinal)
         {
             var shared = Parameters;
             try
             {
-                var inSlug = false;
                 foreach (var choice in choices)
                 {
-                    if (commonLine != null && choice.ContourOrdinal == perimeterOrdinal)
-                    {
-                        // The rapid out of a cutout's slug before it is still made head up.
-                        Parameters = shared;
-                        var first = result.Codes.Count;
-                        EmitCommonLinePerimeter(result, shapes[perimeterOrdinal], commonLine);
-                        if (inSlug && first < result.Codes.Count && result.Codes[first] is RapidMove)
-                            result.Codes.Insert(first, new Comment(HeadRaise.Marker));
-                        inSlug = false;
-                        continue;
-                    }
                     // A contour's own settings apply to its emission alone; scribes and every
                     // other contour keep the shared settings.
                     Parameters = contourParameters?[choice.ContourOrdinal] ?? shared;
                     var shape = shapes[choice.ContourOrdinal];
-                    var arrival = result.Codes.Count;
+                    EmitContour(result, shape, choice.Point, shape.Entities[choice.EntityOrdinal],
-                    var leftInSlug = EmitContour(result, shape, choice.Point, shape.Entities[choice.EntityOrdinal],
                         choice.ContourOrdinal == perimeterOrdinal ? ContourType.External : null,
-                        exactCirclePrograms: true, scrapPierce: choice.Pierce,
+                        exactCirclePrograms: true, scrapPierce: choice.Pierce);
-                        stopAtCenterLine: contourParameters?[choice.ContourOrdinal] == null,
-                        memoContour: choice.ContourOrdinal);
-                    // A cutout's lead-out ends in its slug, which may drop or tip once cut free, so
-                    // the rapid out over the cut is made head up. An overcut or no lead-out leaves
-                    // from the cut itself and stays head down.
-                    if (inSlug && arrival < result.Codes.Count && result.Codes[arrival] is RapidMove or SubProgramCall)
-                        result.Codes.Insert(arrival, new Comment(HeadRaise.Marker));
-                    inSlug = leftInSlug;
                 }
             }
             finally
@@ -463,17 +433,14 @@ namespace OpenNest.CNC.CuttingStrategy
         private static bool SameVector(Vector a, Vector b) => SameBits(a.X, b.X) && SameBits(a.Y, b.Y);
         private static bool SameBits(double a, double b) => BitConverter.DoubleToInt64Bits(a) == BitConverter.DoubleToInt64Bits(b);
 
-        /// <returns>Whether the contour is a cutout left by a lead-out, which ends in its slug.</returns>
+        private void EmitContour(
-        private bool EmitContour(
             Program program,
             Shape shape,
             Vector point,
             Entity entity,
             ContourType? forceType = null,
             bool exactCirclePrograms = false,
-            Vector? scrapPierce = null,
+            Vector? scrapPierce = null
-            bool stopAtCenterLine = false,
-            int? memoContour = null
         )
         {
             var contourType = forceType ?? DetectContourType(shape);
@@ -505,11 +472,9 @@ namespace OpenNest.CNC.CuttingStrategy
                     leadIn = StraightLeadIn(point, holePierce, out normal);
                 else
                 {
-                    if (stopAtCenterLine)
-                        leadIn = StopAtCenterLine(shape, point, leadIn, normal, winding);
                     leadIn = ClampLeadInForCircle(leadIn, circle, point, normal,
                         Parameters.GetEffectivePierceClearance());
-                    leadIn = PierceZone(memoContour, shape, point, leadIn, normal, winding);
+                    leadIn = ResolvePierceZone(shape, point, leadIn, normal, Parameters.GetPierceZoneRadius(), winding);
                 }
 
                 // Build hole sub-program relative to (0,0)
@@ -527,8 +492,7 @@ namespace OpenNest.CNC.CuttingStrategy
                 var reindexed = relativeShape.ReindexAt(relativePoint, relativeCircle);
 
                 subPgm.Codes.AddRange(ConvertShapeToMoves(reindexed, relativePoint));
-                var holeLeadOut = leadOut.Generate(relativePoint, normal, winding);
+                subPgm.Codes.AddRange(leadOut.Generate(relativePoint, normal, winding));
-                subPgm.Codes.AddRange(holeLeadOut);
                 subPgm.Mode = Mode.Incremental;
 
                 // Deduplicate: check if an identical sub-program already exists
@@ -547,12 +511,11 @@ namespace OpenNest.CNC.CuttingStrategy
                     }
                 );
 
-                return holeLeadOut.Count > 0;
+                return;
             }
 
             var turn = LeadTurn(contourType, winding);
             double leadInNormal;
-            var configuredLeadIn = leadIn;
             // A planner-placed scrap pierce replaces the configured lead-in with a straight one.
             if (scrapPierce is { } pierce)
                 leadIn = StraightLeadIn(point, pierce, out leadInNormal);
@@ -561,12 +524,9 @@ namespace OpenNest.CNC.CuttingStrategy
                 leadIn = ResolveLeadIn(shape, point, entity, contourType, leadIn, winding,
                     Parameters.GetEffectivePierceClearance(), out leadInNormal);
                 if (contourType == ContourType.Internal)
-                {
+                    leadIn = ResolvePierceZone(shape, point, leadIn, leadInNormal, Parameters.GetPierceZoneRadius(), turn);
-                    if (stopAtCenterLine)
-                        leadIn = StopAtCenterLine(shape, point, leadIn, leadInNormal, turn);
-                    leadIn = PierceZone(memoContour, shape, point, leadIn, leadInNormal, turn);
-                }
             }
+            program.Codes.AddRange(leadIn.Generate(point, leadInNormal, turn));
 
             var reindexedShape = shape.ReindexAt(point, entity);
 
@@ -579,7 +539,6 @@ namespace OpenNest.CNC.CuttingStrategy
             var leadOutNormal = normal;
             if (tabbed)
             {
-                var first = reindexedShape.Entities.Count > 0 ? reindexedShape.Entities[0] : null;
                 reindexedShape = TrimShapeForTab(reindexedShape, point, Parameters.TabConfig.Size);
 
                 // Leave from where the trimmed cut actually ends, on that entity's normal:
@@ -589,18 +548,6 @@ namespace OpenNest.CNC.CuttingStrategy
                     var last = reindexedShape.Entities[^1];
                     leadOutPoint = EntityEndPoint(last);
                     leadOutNormal = ComputeNormal(leadOutPoint, last, contourType, winding);
-
-                    // Straight leads either side of a tab that wraps a corner share its bisector,
-                    // as they share the edge normal on a straight edge.
-                    if (ReferenceEquals(leadIn, configuredLeadIn) && leadIn is LineLeadIn lineIn
-                        && leadOut is LineLeadOut lineOut && first is Line or Arc
-                        && TabCornerNormal(shape, point, TravelTangent(first, point), leadInNormal, lineIn,
-                            leadOutPoint, TravelTangent(last, leadOutPoint), leadOutNormal, lineOut, winding,
-                            turn, Parameters.GetEffectivePierceClearance()) is { } tabNormal)
-                    {
-                        leadInNormal = tabNormal;
-                        leadOutNormal = tabNormal;
-                    }
                 }
             }
             else
@@ -609,11 +556,8 @@ namespace OpenNest.CNC.CuttingStrategy
                     Parameters.GetEffectivePierceClearance(), out leadOutNormal);
             }
 
-            program.Codes.AddRange(leadIn.Generate(point, leadInNormal, turn));
             program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
-            var leadOutCodes = leadOut.Generate(leadOutPoint, leadOutNormal, turn);
+            program.Codes.AddRange(leadOut.Generate(leadOutPoint, leadOutNormal, turn));
-            program.Codes.AddRange(leadOutCodes);
-            return contourType != ContourType.External && leadOutCodes.Count > 0;
         }
 
         /// <summary>
@@ -923,18 +867,10 @@ namespace OpenNest.CNC.CuttingStrategy
         /// A turn whose offset over the tangent is within chaining tolerance is smooth,
         /// not a corner.
         /// </summary>
-        private static CornerKind ClassifyCorner(ContourCorner corner, RotationType winding) =>
+        private static CornerKind ClassifyCorner(ContourCorner corner, RotationType winding)
-            ClassifyTurn(corner.TangentIn, corner.TangentOut, winding);
-
-        /// <summary>
-        /// The corner a contour of <paramref name="winding"/> would make turning from travel
-        /// direction <paramref name="tangentIn"/> to <paramref name="tangentOut"/>, classified
-        /// exactly as a shared vertex is (see <see cref="TryClassifyAutomaticStartCorner"/>).
-        /// </summary>
-        internal static CornerKind ClassifyTurn(Vector tangentIn, Vector tangentOut, RotationType winding)
         {
-            var cross = tangentIn.X * tangentOut.Y - tangentIn.Y * tangentOut.X;
+            var cross = corner.TangentIn.X * corner.TangentOut.Y - corner.TangentIn.Y * corner.TangentOut.X;
-            var dot = tangentIn.DotProduct(tangentOut);
+            var dot = corner.TangentIn.DotProduct(corner.TangentOut);
             var turn = winding == RotationType.CCW ? cross : -cross;
 
             if (System.Math.Abs(turn) <= Tolerance.Epsilon)
@@ -963,46 +899,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
@@ -1154,28 +1050,16 @@ namespace OpenNest.CNC.CuttingStrategy
         /// <summary>
         /// Keeps a hole's lead-in pierce <paramref name="pierceRadius"/> clear of the hole wall.
         /// A lead-in whose pierce already keeps it, or that pierces on the contour itself, is
-        /// returned as given. Otherwise the pierce moves straight in from the wall to the hole's
+        /// returned as given. Otherwise the pierce moves onto the line from
-        /// center line, or the lead's own length in when that comes first (see
+        /// <paramref name="point"/> toward the hole's pole of inaccessibility (the centre of a
-        /// <see cref="StopAtCenterLine"/>). A lead that cannot keep the zone there moves onto the
+        /// round hole), as close to the contour as the zone allows, and the lead becomes a
-        /// line from <paramref name="point"/> toward the nearest point that keeps it (see
+        /// straight line from there, generated with <paramref name="normal"/>. A hole too small
-        /// <see cref="ErodedPierce"/>) or else the hole's pole of inaccessibility (the center of a
-        /// round hole), as close to the contour as the zone allows. Either way the lead becomes
-        /// a straight line from there, generated with <paramref name="normal"/>. A hole too small
         /// for the zone is pierced at the pole itself, its best clearance; the lead validator and
         /// pre-post review still report the shortfall. Reads only the hole's own geometry, so it
         /// knows nothing of parts nested inside the hole. Shared by program generation and the
         /// manual placement preview. <paramref name="turn"/> is the hole's
         /// <see cref="LeadTurn"/>, which places a curved lead's pierce.
         /// </summary>
-        // The memoized resolution for a contour the preparation emits by ordinal.
-        private LeadIn PierceZone(int? contour, Shape hole, Vector point, LeadIn leadIn, double normal, RotationType turn)
-        {
-            var radius = Parameters.GetPierceZoneRadius();
-            return PierceZones != null && contour is { } ordinal
-                ? PierceZones.Resolve(ordinal, hole, point, leadIn, normal, radius, turn)
-                : ResolvePierceZone(hole, point, leadIn, normal, radius, turn);
-        }
-
         public static LeadIn ResolvePierceZone(Shape hole, Vector point, LeadIn leadIn, double normal,
             double pierceRadius, RotationType turn)
         {
@@ -1187,42 +1071,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, turn)))
-            if (Clear(configured))
                 return leadIn;
 
-            var depth = CenterLineDepth(hole, point, normal, configured.DistanceTo(point));
-            if (depth > Math.Tolerance.Epsilon && Clear(point + Inward(normal) * depth))
-                return new LineLeadIn { Length = depth, ApproachAngle = 90 };
-
             var pole = circle?.Center ?? PolyLabel.Find(polygon, null,
                 System.Math.Max(pierceRadius / 100, Math.Tolerance.ChainTolerance), PoleSearchCells);
             if (!Inside(pole))
                 return leadIn;
 
-            // The pole of a letter can be a stroke away: head for the stroke beside the entry, on
+            // Clearance grows monotonically toward the pole of a convex hole, so the bisection
-            // its center line when the lead reaches that far.
-            var reach = configured.DistanceTo(point);
-            var toward = pole;
-            if (circle == null && ErodedPierce.Find(hole, System.Math.Max(pierceRadius, reach), new[] { point }, 1)
-                .Pierces is [var eroded] && Clear(eroded))
-                toward = eroded;
-
-            // Clearance grows monotonically along this line in a convex hole, so the bisection
             // finds the shortest clear lead; in other holes it still ends on a clear point.
-            var pierce = toward;
+            var pierce = pole;
-            if (Clear(toward) && (reach < pierceRadius || toward == pole))
+            if (Clear(pole))
             {
                 double low = 0, high = 1;
                 for (var i = 0; i < 40; i++)
                 {
                     var middle = (low + high) / 2;
-                    if (Clear(point + (toward - point) * middle))
+                    if (Clear(point + (pole - point) * middle))
                         high = middle;
                     else
                         low = middle;
                 }
-                pierce = point + (toward - point) * high;
+                pierce = point + (pole - point) * high;
             }
 
             var length = pierce.DistanceTo(point);
@@ -1243,97 +1114,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,11 +1127,6 @@ 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
@@ -1372,22 +1147,6 @@ namespace OpenNest.CNC.CuttingStrategy
 
         private static Shape TrimShapeForTab(Shape shape, Vector center, double tabSize)
         {
-            // A round perimeter is one circle entered at `center`: cut it as an arc from the entry
-            // that stops the tab's chord short of it, travelling the circle's own way.
-            if (shape.Entities is [Circle round] && round.Radius > tabSize / 2)
-            {
-                var entry = round.Center.AngleTo(center);
-                var gap = 2 * 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 +1323,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 +1339,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);
 

OpenNest.Core/CNC/CuttingStrategy/CuttingParameters.cs

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

OpenNest.Core/CNC/CuttingStrategy/ErodedPierce.cs

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

OpenNest.Core/CNC/CuttingStrategy/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/HeadHeightLock.cs

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

OpenNest.Core/CNC/HeadRaise.cs

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

OpenNest.Core/CNC/LayerType.cs

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

OpenNest.Core/CNC/PostMarkers.cs

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

OpenNest.Core/CNC/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)
         {

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

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

OpenNest.Core/Converters/ConvertProgram.cs

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

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

OpenNest.Core/CutOffSegments.cs

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

OpenNest.Core/CutOffSettings.cs

@@ -25,7 +25,5 @@ namespace OpenNest
 
         /// <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

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

OpenNest.Core/Diagnostics/CommonLineReview.cs

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

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,29 +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}";
-    }
-
-    /// <summary>A short canvas label: the part's sequence number and what is wrong.</summary>
-    public static string Label(PlateEdgeFinding finding) =>
-        $"{finding.PartId + 1} " + (finding.OffPlate ? "off plate" : "outside work area");
-
-    public static string Details(PlateEdgeFinding finding, Units capturedUnits, IFormatProvider provider = null)
-    {
-        var units = UnitsHelper.GetShortString(capturedUnits);
-        return (finding.OffPlate ? "Off the plate" : "Outside work area") + $": part {finding.PartId + 1}\n"
-            + finding.Message + "\n"
-            + $"Marker: ({Number(finding.Marker.X, provider)}, {Number(finding.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);
@@ -62,27 +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();
-
-    /// <inheritdoc cref="HitTest(IEnumerable{PlateOverlapPair}, Func{Vector, Vector}, Vector, int)"/>
-    public static IReadOnlyList<PlateEdgeFinding> HitTest(IEnumerable<PlateEdgeFinding> findings,
-        Func<Vector, Vector> worldToScreen, Vector pointer, int deviceDpi) =>
-        findings.Where(finding => Hits(worldToScreen(finding.Marker), pointer, deviceDpi))
-            .OrderBy(finding => finding.PartId).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,35 +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>();
-    /// <summary>Known plate-edge findings safe to draw, retained like <see cref="DisplayPairs"/>.</summary>
-    public IReadOnlyList<PlateEdgeFinding> DisplayEdgeFindings { get; private set; } =
-        Array.Empty<PlateEdgeFinding>();
     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 && Report.EdgeFindings.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; ")
-            + Edges("; ")
             + $"{uncheckedPartCount} parts could not be checked",
         OverlapCheckStatus.Failed => "Overlap check failed — run Check Overlaps again",
         OverlapCheckStatus.Canceled => "Overlap check canceled",
@@ -59,66 +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");
-        var off = Report.EdgeFindings.Count(finding => finding.OffPlate);
-        var near = Report.EdgeFindings.Count - off;
-        if (off != 0)
-            words.Add($"{off} off plate");
-        if (near != 0)
-            words.Add($"{near} outside work area");
-        return string.Join(", ", words);
-    }
-
-    // Plate-edge counts for the detailed message, each followed by the separator; empty when none.
-    private string Edges(string separator)
-    {
-        var off = Report.EdgeFindings.Count(finding => finding.OffPlate);
-        var near = Report.EdgeFindings.Count - off;
-        return (off == 0 ? "" : $"{off} parts off the plate{separator}")
-            + (near == 0 ? "" : $"{near} parts outside the work area{separator}");
-    }
-
-    // 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")
-            + (Report.EdgeFindings.Count == 0 ? "" : "; " + Edges("; ").TrimEnd(' ', ';'));
-        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.
@@ -141,14 +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;
-        DisplayEdgeFindings = report.EdgeFindings;
         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;
     }
 
@@ -202,17 +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();
-        var sameSheet = displayStamp.SameSheet(plate);
-        var retainedEdges = DisplayEdgeFindings.Where(finding => sameSheet && unchanged[finding.PartId]).ToList();
-        if (retainedEdges.Count != DisplayEdgeFindings.Count)
-            DisplayEdgeFindings = retainedEdges.AsReadOnly();
-        if (DisplayPairs.Count == 0 && DisplayCutOffClampFindings.Count == 0 && DisplaySpacingPairs.Count == 0
-            && DisplayEdgeFindings.Count == 0)
             ClearDisplayPairs();
         else
             observedDisplayStamp = OverlapGeometryStamp.Capture(plate);
@@ -222,8 +133,6 @@ public sealed class OverlapReportState
     {
         DisplayPairs = Array.Empty<PlateOverlapPair>();
         DisplayCutOffClampFindings = Array.Empty<CutOffClampFinding>();
-        DisplaySpacingPairs = Array.Empty<PlateSpacingPair>();
-        DisplayEdgeFindings = Array.Empty<PlateEdgeFinding>();
         displayStamp = null;
         observedDisplayStamp = null;
     }
@@ -239,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

@@ -21,21 +21,10 @@ namespace OpenNest.Diagnostics;
 /// is short of the spacing by more than the slack. Zero spacing enforces nothing, so 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.
-    /// The profile loads inside the scan's error boundary; null means no material.</summary>
-    internal sealed record SpacingInput(int Id, Func<ShapeProfile> Profile, Vector Location);
-
-    /// <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,
         CancellationToken cancellationToken)
@@ -47,61 +36,14 @@ 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 raw = new SpacingOutline[parts.Count];
@@ -109,30 +51,24 @@ internal static class PartSpacingReview
         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,8 +88,7 @@ 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;
@@ -166,21 +101,27 @@ internal static class PartSpacingReview
                 }
                 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,65 +131,21 @@ 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>
-    internal 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>
-    /// Each pair of <paramref name="parts"/> (by position, lower first) in one common-line group of
-    /// <paramref name="plate"/>, with the group's kerf.
-    /// </summary>
-    internal static IReadOnlyDictionary<(int, int), double> CommonLinePairs(Plate plate, IReadOnlyList<Part> parts)
-    {
-        var pairs = new Dictionary<(int, int), double>();
-        if (plate?.CommonLines is not { Count: > 0 } groups)
-            return pairs;
-        var positions = new Dictionary<Part, int>(ReferenceEqualityComparer.Instance);
-        for (var i = 0; i < parts.Count; i++)
-            if (parts[i] != null)
-                positions.TryAdd(parts[i], i);
-        foreach (var group in groups)
-        {
-            var ids = group.Members.Where(positions.ContainsKey).Select(member => positions[member]).ToList();
-            for (var i = 0; i < ids.Count; i++)
-                for (var j = i + 1; j < ids.Count; j++)
-                    pairs[Key(ids[i], ids[j])] = group.Kerf;
-        }
-        return pairs;
-    }
-
-    private static double? CommonLineKerf(Plate plate, Part a, Part b) =>
-        plate.CommonLineGroupOf(a) is { } group && group.Contains(b) ? group.Kerf : null;
-
     private static string Name(Part part) => part.BaseDrawing.Name;
 
     private static bool BoxesTouch(Box a, Box b) =>

OpenNest.Core/Diagnostics/PartSupportReview.cs

@@ -12,9 +12,9 @@ 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
+/// support bed cannot hold it level or, without a bed, its width is in the no-bed 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
+/// locked); without a bed 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
@@ -28,7 +28,8 @@ internal static class PartSupportReview
             token.ThrowIfCancellationRequested();
             var part = plate.Parts[index];
             var parameters = part?.CuttingParameters ?? plate.CuttingParameters;
-            if (part?.BaseDrawing == null || part.BaseDrawing.IsCutOff || !SupportTabSettings.CanTab(parameters, bed))
+            if (part?.BaseDrawing == null || part.BaseDrawing.IsCutOff || parameters?.SupportTabs != true
+                || (bed == null && !parameters.HasNoBedTabRange()))
                 continue;
             var partNumber = index + 1;
             try
@@ -109,7 +110,7 @@ internal static class PartSupportReview
                     ? 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, "))
+                        $"The part is {support.Width:0.####} wide, in the width range tabbed without a support bed, "))
                 + "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.####}).")

OpenNest.Core/Diagnostics/PlateEdgeReview.cs

@@ -1,230 +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>Outside the work area</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;
-
-    /// <summary>
-    /// The sheet a plate's parts must stay on, owned and immutable, so the desktop label's worker
-    /// never reads the live plate. <see cref="Sheet"/> and <see cref="Work"/> are in the parts'
-    /// signed placement frame; <see cref="Inset"/> is the outline's clearance, the largest edge spacing.
-    /// </summary>
-    internal sealed record SheetFrame(Box Sheet, Box Work, SheetOutline Outline, Vector Origin, double Inset)
-    {
-        /// <summary>The plate's frame; throws <see cref="ArgumentException"/> for an unusable size or spacing.</summary>
-        internal static SheetFrame Of(Plate plate)
-        {
-            var size = plate.Size;
-            if (!(size.Length > 0) || !(size.Width > 0) || !double.IsFinite(size.Length) || !double.IsFinite(size.Width))
-                throw new ArgumentException($"plate size {size} is not a positive, finite size.");
-            var edges = plate.EdgeSpacing;
-            if (!new[] { edges.Left, edges.Bottom, edges.Right, edges.Top }.All(e => double.IsFinite(e) && e >= 0))
-                throw new ArgumentException("plate edge spacing is not finite and non-negative on every side.");
-            var sheet = plate.BoundingBox(includeParts: false);
-            return new SheetFrame(sheet, plate.WorkArea(), plate.Outline, new Vector(sheet.X, sheet.Y),
-                System.Math.Max(System.Math.Max(edges.Left, edges.Right), System.Math.Max(edges.Top, edges.Bottom)));
-        }
-    }
-
-    /// <summary>What is wrong with one part; <see cref="Detail"/> follows its quoted name.</summary>
-    internal readonly record struct Verdict(bool OffPlate, string Detail, Vector Marker);
-
-    internal static void Add(Plate plate, int plateNumber, List<PostVerificationFinding> findings,
-        CancellationToken cancellationToken)
-    {
-        if (plate.Parts.Count == 0)
-            return;
-        SheetFrame frame;
-        try
-        {
-            frame = SheetFrame.Of(plate);
-        }
-        catch (ArgumentException exception)
-        {
-            findings.Add(new(PostVerificationKind.Incomplete, plateNumber, null, null,
-                "Plate edge check: " + exception.Message));
-            return;
-        }
-        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
-            {
-                // The placed program first: its leads and scribes may leave a sheet its material stays on.
-                var verdict = PastSheet(part, frame.Sheet, cancellationToken)
-                    ?? (PartSpacingReview.Profile(part, profiles) is { } profile
-                        ? Check(profile, part.Location, frame)
-                        : null);
-                if (verdict is { } found)
-                    findings.Add(new(found.OffPlate ? PostVerificationKind.OffPlate : PostVerificationKind.EdgeSpacing,
-                        plateNumber, partNumber, null, $"'{part.BaseDrawing.Name}' {found.Detail}")
-                    { Location = found.Marker });
-            }
-            catch (Exception exception) when (IsInvalid(exception))
-            {
-                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, partNumber, null,
-                    "Plate edge check: " + exception.Message));
-            }
-        }
-    }
-
-    /// <summary>
-    /// The desktop label's check: clean material only (snapshots hold no leads), run on the
-    /// overlap worker from owned geometry. Findings and issues keep input ids.
-    /// </summary>
-    internal static void Add(PlateOverlapSnapshot snapshot, List<PlateEdgeFinding> found,
-        List<PlateOverlapIssue> issues, CancellationToken cancellationToken)
-    {
-        var frame = snapshot.Frame;
-        if (frame == null)
-            return;
-        var profiles = new Dictionary<(OverlapSource, long), ShapeProfile>();
-        var unreadable = snapshot.Issues.Where(issue => issue.PartBId == null)
-            .Select(issue => issue.PartAId).ToHashSet();
-        foreach (var part in snapshot.Parts)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            if (unreadable.Contains(part.Id))
-                continue;
-            try
-            {
-                if (PartSpacingReview.Profile(part, profiles) is { } profile
-                    && Check(profile, part.Location, frame) is { } verdict)
-                    found.Add(new PlateEdgeFinding(part.Id, part.Name, verdict.OffPlate,
-                        $"'{part.Name}' {verdict.Detail}", verdict.Marker));
-            }
-            catch (Exception exception) when (IsInvalid(exception))
-            {
-                issues.Add(new PlateOverlapIssue(part.Id, null, exception.Message));
-            }
-        }
-    }
-
-    /// <summary>Clean material at <paramref name="location"/> against the sheet; null when it keeps the edge spacing.</summary>
-    internal static Verdict? Check(ShapeProfile profile, Vector location, SheetFrame frame)
-    {
-        var bounds = profile.Perimeter.BoundingBox.Translate(location);
-        if (Describe(Furthest(null, bounds, bounds.Center, frame.Sheet)) is { } past)
-            return past;
-        PathsD region = null;
-        if (frame.Outline != null)
-        {
-            var material = SpacingOutline.Build(profile, location, 0)
-                ?? throw new ArgumentException("Part material has no closed perimeter.");
-            region = new PathsD { ClipperBridge.ToPath(material.Perimeter, positive: true) };
-            if (!frame.Outline.Holds(region, 0, frame.Origin, Slack))
-                return new Verdict(true, "lies outside the plate's outline or over one of its obstacles.",
-                    bounds.Center);
-        }
-        if (Shortest(bounds, frame.Sheet, frame.Work) is { } close)
-            return new Verdict(false, $"is outside the work area: {close.Gap:F3} from the plate's {close.Edge} "
-                + $"edge, inside its {close.Spacing:F3} edge spacing.", close.Marker);
-        if (region != null && frame.Inset > 0 && !frame.Outline.Holds(region, frame.Inset, frame.Origin, Slack))
-            return new Verdict(false, $"is outside the work area: inside the {frame.Inset:F3} edge spacing of the "
-                + "plate's outline or one of its obstacles.", bounds.Center);
-        return null;
-    }
-
-    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 Verdict? 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;
-            worst = Furthest(worst, move.Curve.ToEntity().BoundingBox, move.Curve.Midpoint, sheet);
-        }
-        return Describe(worst);
-    }
-
-    private static Verdict? Describe(Past? past) => past is { } p
-        ? new Verdict(true, $"runs {p.Distance:F3} past the plate's {p.Edge} edge.", p.Marker)
-        : null;
-
-    private static Past? Furthest(Past? worst, Box box, Vector middle, Box sheet)
-    {
-        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("Part 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 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,28 +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();
-        var issues = material.Issues.ToList();
+        return new PlateOverlapSnapshot(material.Parts.ToList(), material.Issues.ToList(),
-        PlateEdgeReview.SheetFrame frame = null;
+            material.Clamps.ToList(), cutoffs.ToList());
-        if (material.Parts.Count != 0)
-        {
-            try
-            {
-                frame = PlateEdgeReview.SheetFrame.Of(plate);
-            }
-            catch (ArgumentException exception)
-            {
-                // Reported against the first part: the sheet itself cannot be checked.
-                issues.Add(new PlateOverlapIssue(material.Parts[0].Id, null, "Plate edge check: " + exception.Message));
-            }
-        }
-        return new PlateOverlapSnapshot(material.Parts.ToList(), issues,
-            material.Clamps.ToList(), cutoffs.ToList(), plate.PartSpacing,
-            PartSpacingReview.CommonLinePairs(plate, parts), frame);
     }
 
     /// <summary>
@@ -239,18 +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);
-        var edgeFindings = new List<PlateEdgeFinding>();
-        PlateEdgeReview.Add(snapshot, edgeFindings, 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(), edgeFindings.OrderBy(finding => finding.PartId).ToList());
     }
 
     /// <summary>
@@ -371,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,17 +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, List<PlateEdgeFinding> edgeFindings = 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();
-        EdgeFindings = (edgeFindings ?? new List<PlateEdgeFinding>()).AsReadOnly();
     }
 
     /// <summary>The owned input this report was computed from; the baseline for incremental rechecks.</summary>
@@ -37,29 +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>
-    /// Parts off the sheet or inside its edge spacing, judged on clean material. Only a plate
-    /// capture carries the sheet; a bare group of parts has none. Unreadable parts join
-    /// <see cref="SpacingIssues"/>.
-    /// </summary>
-    public IReadOnlyList<PlateEdgeFinding> EdgeFindings { 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;
 }
 
@@ -121,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; }
@@ -129,19 +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>
-/// A part off the sheet (<see cref="OffPlate"/>) or closer to its edge than the edge spacing.
-/// <see cref="Marker"/> is where it leaves the sheet or the middle of its gap to the edge.
-/// </summary>
-public sealed record PlateEdgeFinding(int PartId, string PartName, bool OffPlate, string Message, Vector Marker);
-
 /// <summary>
 /// One connected island of shared material in world coordinates, after hole subtraction:
 /// a counterclockwise outline and its clockwise holes.
@@ -183,17 +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,
-        PlateEdgeReview.SheetFrame frame = 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;
-        Frame = frame;
     }
 
     internal IReadOnlyList<CapturedOverlapPart> Parts { get; }
@@ -202,16 +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; }
-
-    /// <summary>The sheet the parts must stay on; null for a bare group of parts or an unusable sheet.</summary>
-    internal PlateEdgeReview.SheetFrame Frame { 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++)
             {
@@ -153,7 +144,8 @@ public static class PostVerificationAnalyzer
                         && 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 +224,8 @@ 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);
@@ -351,53 +347,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 +382,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 +408,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 +415,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 +450,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,

OpenNest.Core/Diagnostics/PostVerificationReport.cs

@@ -40,25 +40,7 @@ public enum PostVerificationKind
     /// 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,
+    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>
@@ -110,12 +92,6 @@ public sealed class PostVerificationReport
             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, "Outside work area");
-        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);
-        }
-    }
-}

OpenNest.Core/Drawing.cs

@@ -66,7 +66,6 @@ namespace OpenNest
 
         public string Customer { get; set; }
 
-        /// <summary>Nesting order: higher numbers nest first. Zero is the default.</summary>
         public int Priority { get; set; }
 
         public DwgQty Quantity;
@@ -120,14 +119,6 @@ namespace OpenNest
         /// </summary>
         public bool CutFirst { get; set; }
 
-        /// <summary>
-        /// Lets automatic nesting place this drawing's parts one kerf apart so they share a cut
-        /// (see docs/common-line-cutting.md), when the nest's common-line usage allows it. Off by
-        /// default: a shared edge is cut once from the centerline, which some customers'
-        /// edge-quality requirements do not accept.
-        /// </summary>
-        public bool AllowCommonLine { get; set; }
-
         public NestConstraints Constraints { get; set; }
 
         public SourceInfo Source { get; set; }
@@ -160,12 +151,6 @@ namespace OpenNest
         /// </summary>
         public List<TabbedCutouts.TabbedCutout> TabbedCutouts { get; set; } = new List<TabbedCutouts.TabbedCutout>();
 
-        /// <summary>
-        /// Annotations shown in the CAD Converter. They store placement only, are measured from the
-        /// geometry when shown and never affect <see cref="Program"/>.
-        /// </summary>
-        public List<Dimensions.DrawingDimension> Dimensions { get; set; } = new List<Dimensions.DrawingDimension>();
-
         /// <summary>
         /// Complete set of source entities with stable GUIDs.
         /// Null when the drawing was created from G-code or an older nest file.

OpenNest.Core/Geometry/BoundingBox.cs

@@ -85,28 +85,5 @@ namespace OpenNest.Geometry
 
             return new Box(left, bottom, right - left, top - bottom);
         }
-
-        /// <summary>
-        /// Whether <paramref name="inner"/> lies inside <paramref name="outer"/>, allowing
-        /// <see cref="Math.Tolerance.Epsilon"/> on every side.
-        /// </summary>
-        internal static bool IsWithin(Box inner, Box outer)
-        {
-            var eps = Math.Tolerance.Epsilon;
-            return inner.Left >= outer.Left - eps
-                && inner.Right <= outer.Right + eps
-                && inner.Bottom >= outer.Bottom - eps
-                && inner.Top <= outer.Top + eps;
-        }
-
-        /// <summary>The smallest box covering both 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);
-            var right = System.Math.Max(a.Right, b.Right);
-            var top = System.Math.Max(a.Top, b.Top);
-            return new Box(left, bottom, right - left, top - bottom);
-        }
     }
 }

OpenNest.Core/Geometry/Collision.cs

@@ -7,7 +7,7 @@ namespace OpenNest.Geometry
     /// <summary>
     /// Polygon overlap test with hole subtraction, used by engine and validation per-pair
     /// checks. It was written as the reference for a GPU kernel; that port is on hold in
-    /// favor of Clipper2, starting with the material-overlap diagnostic. Engine callers
+    /// favour of Clipper2, starting with the material-overlap diagnostic. Engine callers
     /// stay on this kernel until a Clipper2 near-contact differential and the layout gate
     /// pass.
     /// <para>

OpenNest.Core/Geometry/DrawingAligner.cs

@@ -44,7 +44,7 @@ namespace OpenNest.Geometry
         /// <summary>
         /// Aligns <paramref name="newProgram"/> onto <paramref name="oldProgram"/>.
         /// Both programs are treated as read-only. Throws
-        /// <see cref="OperationCanceledException"/> only when canceled before any
+        /// <see cref="OperationCanceledException"/> only when cancelled before any
         /// measurable work; work limits reached mid-run are reported as reasons on
         /// the result instead.
         /// </summary>
@@ -504,7 +504,7 @@ namespace OpenNest.Geometry
             var newC = Centroid(@new.Outer.Samples);
             for (var i = 0; i < seeds.Count; i++)
             {
-                var rotated = newC.Rotate(seeds[i].Item1);
+                var rotated = Rotate(newC, seeds[i].Item1);
                 seeds[i] = (seeds[i].Item1, oldC - rotated);
             }
             return seeds;
@@ -569,7 +569,7 @@ namespace OpenNest.Geometry
                 {
                     var p = @new.Outer.Samples[i].Position;
                     var m = preMirror(p.X, p.Y);
-                    positions[idx++] = new Vector(m.X, m.Y).Rotate(rotation) + translation;
+                    positions[idx++] = Rotate(new Vector(m.X, m.Y), rotation) + translation;
                 }
                 if (!includeHoles)
                     return;
@@ -578,7 +578,7 @@ namespace OpenNest.Geometry
                     {
                         var p = @new.Holes[h].Samples[i].Position;
                         var m = preMirror(p.X, p.Y);
-                        positions[idx++] = new Vector(m.X, m.Y).Rotate(rotation) + translation;
+                        positions[idx++] = Rotate(new Vector(m.X, m.Y), rotation) + translation;
                     }
             }
 
@@ -650,7 +650,7 @@ namespace OpenNest.Geometry
                     return null; // nonfinite update
 
                 rotation += dTheta;
-                translation = translation.Rotate(dTheta) + dT;
+                translation = Rotate(translation, dTheta) + dT;
 
                 var rms = System.Math.Sqrt(order.Average(i => residuals[i] * residuals[i]));
 
@@ -790,7 +790,7 @@ namespace OpenNest.Geometry
             if (double.IsNaN(dTheta) || double.IsInfinity(dTheta))
                 return false;
 
-            var r = cq.Rotate(dTheta);
+            var r = Rotate(cq, dTheta);
             dTranslation = ct - r;
             return !double.IsNaN(dTranslation.X) && !double.IsNaN(dTranslation.Y);
         }
@@ -866,11 +866,11 @@ namespace OpenNest.Geometry
             var outerCenter = Centroid(old.Outer.Samples);
             foreach (var flip in new[] { System.Math.PI, System.Math.PI / 2, -System.Math.PI / 2 })
             {
-                var anchor = (-outerCenter).Rotate(flip) + outerCenter;
+                var anchor = Rotate(-outerCenter, flip) + outerCenter;
                 var probe = new Candidate
                 {
                     Rotation = NormalizeAngle(best.Rotation + flip),
-                    Translation = best.Translation.Rotate(flip) + anchor,
+                    Translation = Rotate(best.Translation, flip) + anchor,
                 };
                 var refined = FitIcp(
                     old,
@@ -971,8 +971,8 @@ namespace OpenNest.Geometry
             var limit = options.SamplingSpacing * 0.5;
             foreach (var s in @new.Outer.Samples)
             {
-                var pa = s.Position.Rotate(a.Rotation) + a.Translation;
+                var pa = Rotate(s.Position, a.Rotation) + a.Translation;
-                var pb = s.Position.Rotate(best.Rotation) + best.Translation;
+                var pb = Rotate(s.Position, best.Rotation) + best.Translation;
                 if (pa.DistanceTo(pb) > limit)
                     return true;
             }
@@ -993,7 +993,7 @@ namespace OpenNest.Geometry
             var newTotal = 0;
             foreach (var s in AllNewSamples(@new))
             {
-                var p = s.Position.Rotate(pose.Rotation) + pose.Translation;
+                var p = Rotate(s.Position, pose.Rotation) + pose.Translation;
                 newTotal++;
                 if (TryClosestSegment(p, oldSegments, out var c) && p.DistanceTo(c) <= spanBound)
                     newMatched++;
@@ -1005,8 +1005,8 @@ namespace OpenNest.Geometry
             var posed = AllNewSegments(@new);
             for (var i = 0; i < posed.Length; i++)
                 posedNewSegments[i] = new Line(
-                    posed[i].StartPoint.Rotate(pose.Rotation) + pose.Translation,
+                    Rotate(posed[i].StartPoint, pose.Rotation) + pose.Translation,
-                    posed[i].EndPoint.Rotate(pose.Rotation) + pose.Translation
+                    Rotate(posed[i].EndPoint, pose.Rotation) + pose.Translation
                 );
 
             var oldMatched = 0;
@@ -1034,7 +1034,7 @@ namespace OpenNest.Geometry
             var distances = new List<double>();
             foreach (var s in AllNewSamples(@new))
             {
-                var p = s.Position.Rotate(pose.Rotation) + pose.Translation;
+                var p = Rotate(s.Position, pose.Rotation) + pose.Translation;
                 if (TryClosestSegment(p, oldSegments, out var c))
                     distances.Add(p.DistanceTo(c));
             }
@@ -1096,7 +1096,7 @@ namespace OpenNest.Geometry
             var path = new PathD(points.Length);
             foreach (var p in points)
             {
-                var q = p.Rotate(rotation) + translation;
+                var q = Rotate(p, rotation) + translation;
                 if (double.IsNaN(q.X) || double.IsNaN(q.Y))
                     return null;
                 path.Add(new PointD(q.X, q.Y));
@@ -1137,6 +1137,13 @@ namespace OpenNest.Geometry
             return samples.Length > 0 ? sum * (1.0 / samples.Length) : new Vector();
         }
 
+        private static Vector Rotate(Vector v, double angle)
+        {
+            var cos = System.Math.Cos(angle);
+            var sin = System.Math.Sin(angle);
+            return new Vector(v.X * cos - v.Y * sin, v.X * sin + v.Y * cos);
+        }
+
         private static double NormalizeAngle(double angle)
         {
             var twoPi = 2 * System.Math.PI;

OpenNest.Core/Geometry/EntityEndpoints.cs

@@ -1,26 +0,0 @@
-namespace OpenNest.Geometry
-{
-    internal static class EntityEndpoints
-    {
-        /// <summary>The start and end of a line or arc; false for any other entity.</summary>
-        public static bool TryGet(Entity entity, out Vector start, out Vector end)
-        {
-            switch (entity)
-            {
-                case Line line:
-                    start = line.StartPoint;
-                    end = line.EndPoint;
-                    return true;
-
-                case Arc arc:
-                    start = arc.StartPoint();
-                    end = arc.EndPoint();
-                    return true;
-
-                default:
-                    start = end = default;
-                    return false;
-            }
-        }
-    }
-}

OpenNest.Core/Geometry/GeometryOptimizer.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 using OpenNest.Math;
 
@@ -11,14 +10,14 @@ namespace OpenNest.Geometry
         public static void Optimize(IList<Arc> arcs) =>
             MergePass(
                 arcs,
-                (a, b) => a.IsCoradialTo(b),
+                (list, item, i) => list.GetCoradialArs(item, i),
                 (Arc a, Arc b, out Arc joined) => TryJoinArcs(a, b, out joined)
             );
 
         public static void Optimize(IList<Line> lines) =>
             MergePass(
                 lines,
-                (a, b) => a.IsCollinearTo(b),
+                (list, item, i) => list.GetCollinearLines(item, i),
                 (Line a, Line b, out Line joined) => TryJoinLines(a, b, out joined)
             );
 
@@ -58,120 +57,11 @@ namespace OpenNest.Geometry
             }
         }
 
-        /// <summary>
-        /// Replaces arcs of one center, radius and layer that together cover the whole circle with
-        /// a <see cref="Circle"/>. CAM exports often overshoot the seam of a hole and return along
-        /// a short chord; such a line, lying wholly on the overlap, goes with the arcs. Arcs that
-        /// leave a gap, or overlap by more than <see cref="MaxSeamOverlap"/>, are left alone.
-        /// </summary>
-        public static void JoinFullCircles(List<Entity> entities)
-        {
-            var groups = new List<List<Arc>>();
-            foreach (var arc in entities.OfType<Arc>())
-            {
-                if (!SpecialLayers.IsMaterial(arc.Layer))
-                    continue;
-
-                var group = groups.Find(g => IsSameCircle(g[0], arc));
-                if (group == null)
-                    groups.Add(new List<Arc> { arc });
-                else
-                    group.Add(arc);
-            }
-
-            foreach (var group in groups)
-            {
-                var longest = group.OrderByDescending(a => a.SweepAngle()).First();
-                var tolerance = Tolerance.ChainTolerance / longest.Radius;
-                var spans = group.Select(ToSpan).OrderBy(s => s.Start).ToList();
-                var overlap = spans.Sum(s => s.Sweep) - Angle.TwoPI;
-
-                if (group.Count < 2 || overlap > MaxSeamOverlap || !CoversCircle(spans, tolerance))
-                    continue;
-
-                var chords = entities
-                    .OfType<Line>()
-                    .Where(line => IsSeamChord(line, longest, spans, tolerance))
-                    .ToList();
-
-                var index = entities.FindIndex(e => e is Arc arc && group.Contains(arc));
-                entities.Insert(
-                    index,
-                    new Circle(longest.Center, longest.Radius)
-                    {
-                        Layer = longest.Layer,
-                        Color = longest.Color,
-                    }
-                );
-                entities.RemoveAll(e => e is Arc arc && group.Contains(arc));
-                entities.RemoveAll(e => e is Line line && chords.Contains(line));
-            }
-        }
-
-        /// <summary>The most the arcs of a joined circle may overlap, in radians: 30 degrees.</summary>
-        public const double MaxSeamOverlap = System.Math.PI / 6;
-
-        private static bool IsSameCircle(Arc a, Arc b) =>
-            a.Layer?.Name == b.Layer?.Name
-            && a.Center.DistanceTo(b.Center) <= Tolerance.ChainTolerance
-            && System.Math.Abs(a.Radius - b.Radius) <= Tolerance.ChainTolerance;
-
-        private static (double Start, double Sweep) ToSpan(Arc arc) =>
-            (Angle.NormalizeRad(arc.IsReversed ? arc.EndAngle : arc.StartAngle), arc.SweepAngle());
-
-        // Walks the spans from angle zero, first crediting whatever part of them wraps past it.
-        private static bool CoversCircle(List<(double Start, double Sweep)> spans, double tolerance)
-        {
-            var reach = spans.Max(s => s.Start + s.Sweep - Angle.TwoPI);
-            foreach (var (start, sweep) in spans)
-            {
-                if (start > reach + tolerance)
-                    return false;
-                reach = System.Math.Max(reach, start + sweep);
-            }
-
-            return reach >= Angle.TwoPI - tolerance;
-        }
-
-        private static bool IsSeamChord(
-            Line line,
-            Arc circle,
-            List<(double Start, double Sweep)> spans,
-            double tolerance
-        )
-        {
-            if (line.Layer?.Name != circle.Layer?.Name)
-                return false;
-
-            var center = circle.Center;
-            bool OnCircle(Vector point) =>
-                System.Math.Abs(point.DistanceTo(center) - circle.Radius) <= Tolerance.ChainTolerance;
-            bool OnOverlap(Vector point)
-            {
-                var angle = System.Math.Atan2(point.Y - center.Y, point.X - center.X);
-                return spans.Count(s =>
-                    {
-                        var offset = Angle.NormalizeRad(angle - s.Start);
-                        return offset <= s.Sweep + tolerance || offset >= Angle.TwoPI - tolerance;
-                    }) >= 2;
-            }
-
-            var middle = new Vector(
-                (line.StartPoint.X + line.EndPoint.X) / 2,
-                (line.StartPoint.Y + line.EndPoint.Y) / 2
-            );
-            return OnCircle(line.StartPoint)
-                && OnCircle(line.EndPoint)
-                && OnOverlap(line.StartPoint)
-                && OnOverlap(line.EndPoint)
-                && OnOverlap(middle);
-        }
-
         private delegate bool TryJoin<T>(T a, T b, out T joined);
 
         private static void MergePass<T>(
             IList<T> items,
-            Func<T, T, bool> related,
+            Func<IList<T>, T, int, List<T>> findCandidates,
             TryJoin<T> tryJoin
         )
             where T : class
@@ -179,7 +69,7 @@ namespace OpenNest.Geometry
             for (var i = 0; i < items.Count; ++i)
             {
                 var item = items[i];
-                var candidates = FindRelated(items, item, i, related);
+                var candidates = findCandidates(items, item, i);
                 var index = 0;
 
                 while (index < candidates.Count)
@@ -324,41 +214,62 @@ namespace OpenNest.Geometry
             return true;
         }
 
-        /// <summary>
+        private static List<Line> GetCollinearLines(
-        /// The items from <paramref name="startIndex"/> on, other than <paramref name="item"/>
+            this IList<Line> lines,
-        /// itself, that are <paramref name="related"/> to it.
+            Line line,
-        /// </summary>
+            int startIndex
-        private static List<T> FindRelated<T>(
-            IList<T> items,
-            T item,
-            int startIndex,
-            Func<T, T, bool> related
         )
-            where T : class
         {
-            var matches = new List<T>();
+            var collinearLines = new List<Line>();
 
             Parallel.For(
                 startIndex,
-                items.Count,
+                lines.Count,
                 index =>
                 {
-                    var candidate = items[index];
+                    var compareLine = lines[index];
 
-                    if (Object.ReferenceEquals(item, candidate))
+                    if (Object.ReferenceEquals(line, compareLine))
                         return;
 
-                    if (!related(item, candidate))
+                    if (!line.IsCollinearTo(compareLine))
                         return;
 
-                    lock (matches)
+                    lock (collinearLines)
                     {
-                        matches.Add(candidate);
+                        collinearLines.Add(compareLine);
                     }
                 }
             );
 
-            return matches;
+            return collinearLines;
+        }
+
+        private static List<Arc> GetCoradialArs(this IList<Arc> arcs, Arc arc, int startIndex)
+        {
+            var coradialArcs = new List<Arc>();
+
+            Parallel.For(
+                startIndex,
+                arcs.Count,
+                index =>
+                {
+                    var compareArc = arcs[index];
+
+                    if (Object.ReferenceEquals(arc, compareArc))
+                        return;
+
+                    if (!arc.IsCoradialTo(compareArc))
+                        return;
+
+                    lock (coradialArcs)
+                    {
+                        coradialArcs.Add(compareArc);
+                    }
+                }
+            );
+
+            return coradialArcs;
         }
     }
 }

OpenNest.Core/Geometry/GeometrySimplifier.cs

@@ -555,7 +555,13 @@ public class GeometrySimplifier
         if (start > 0)
         {
             var prev = entities[start - 1];
-            if (EntityEndpoints.TryGet(prev, out _, out var prevEnd) && prevEnd.DistanceTo(points[0]) < 1e-6)
+            var prevEnd = prev switch
+            {
+                Line l => l.EndPoint,
+                Arc a => a.EndPoint(),
+                _ => Vector.Invalid,
+            };
+            if (prevEnd.IsValid() && prevEnd.DistanceTo(points[0]) < 1e-6)
             {
                 if (prev is Arc)
                     return new TangentEstimate(GetExitDirection(prev), true);
@@ -590,7 +596,13 @@ public class GeometrySimplifier
         if (k + 1 < entities.Count)
         {
             var next = entities[k + 1];
-            if (EntityEndpoints.TryGet(next, out var nextStart, out _) && nextStart.DistanceTo(points[^1]) < 1e-6)
+            var nextStart = next switch
+            {
+                Line l => l.StartPoint,
+                Arc a => a.StartPoint(),
+                _ => Vector.Invalid,
+            };
+            if (nextStart.IsValid() && nextStart.DistanceTo(points[^1]) < 1e-6)
             {
                 if (next is Arc nextArc)
                     return new TangentEstimate(GetEntryDirection(nextArc), true);
@@ -642,20 +654,16 @@ public class GeometrySimplifier
     private static Vector GetEntryDirection(Entity entity) =>
         entity switch
         {
-            Line line => LineDirection(line),
+            Line line => new Vector(
-            Arc arc => ArcTangent(arc, arc.StartAngle),
+                line.EndPoint.X - line.StartPoint.X,
+                line.EndPoint.Y - line.StartPoint.Y
+            ),
+            Arc arc => arc.IsReversed
+                ? new Vector(System.Math.Sin(arc.StartAngle), -System.Math.Cos(arc.StartAngle))
+                : new Vector(-System.Math.Sin(arc.StartAngle), System.Math.Cos(arc.StartAngle)),
             _ => Vector.Invalid,
         };
 
-    private static Vector LineDirection(Line line) =>
-        new(line.EndPoint.X - line.StartPoint.X, line.EndPoint.Y - line.StartPoint.Y);
-
-    /// <summary>The direction of travel along an arc at <paramref name="angle"/>.</summary>
-    private static Vector ArcTangent(Arc arc, double angle) =>
-        arc.IsReversed
-            ? new Vector(System.Math.Sin(angle), -System.Math.Cos(angle))
-            : new Vector(-System.Math.Sin(angle), System.Math.Cos(angle));
-
     /// <summary>
     /// Computes the tangent direction at the last point of a fitted arc,
     /// used to chain tangent continuity to the next arc.
@@ -798,8 +806,13 @@ public class GeometrySimplifier
     private static Vector GetExitDirection(Entity entity) =>
         entity switch
         {
-            Line line => LineDirection(line),
+            Line line => new Vector(
-            Arc arc => ArcTangent(arc, arc.EndAngle),
+                line.EndPoint.X - line.StartPoint.X,
+                line.EndPoint.Y - line.StartPoint.Y
+            ),
+            Arc arc => arc.IsReversed
+                ? new Vector(System.Math.Sin(arc.EndAngle), -System.Math.Cos(arc.EndAngle))
+                : new Vector(-System.Math.Sin(arc.EndAngle), System.Math.Cos(arc.EndAngle)),
             _ => Vector.Invalid,
         };
 

OpenNest.Core/Geometry/Intersect.cs

@@ -192,10 +192,7 @@ namespace OpenNest.Geometry
             double t;
             pts = new List<Vector>();
 
-            // A small circle's whole discriminant is tiny: tangent also means the line stays at its rim.
+            if (det.IsEqualTo(0))
-            var halfChord = det / (4 * a);
-            var depth = circle.Radius - System.Math.Sqrt(System.Math.Max(circle.Radius * circle.Radius - halfChord, 0));
-            if (det.IsEqualTo(0) && depth <= Tolerance.Epsilon)
             {
                 t = -b / (2 * a);
                 var pt1 = new Vector(line.StartPoint.X + t * d1.X, line.StartPoint.Y + t * d1.Y);

OpenNest.Core/Geometry/KeepOutOverlap.cs

@@ -69,7 +69,7 @@ public static class KeepOutOverlap
     /// <summary>
     /// True when the material (perimeter minus holes) shares positive area with the open
     /// rectangle: some boundary edge runs through its interior, or its interior lies wholly
-    /// inside the material (tested at its center).
+    /// inside the material (tested at its centre).
     /// </summary>
     public static bool MaterialEnters(Polygon perimeter, IReadOnlyList<Polygon> holes, Box box)
     {
@@ -80,12 +80,12 @@ public static class KeepOutOverlap
                 if (RingEnters(hole, box))
                     return true;
 
-        var center = new Vector((box.Left + box.Right) / 2, (box.Bottom + box.Top) / 2);
+        var centre = new Vector((box.Left + box.Right) / 2, (box.Bottom + box.Top) / 2);
-        if (!Contains(perimeter, center))
+        if (!Contains(perimeter, centre))
             return false;
         if (holes != null)
             foreach (var hole in holes)
-                if (Contains(hole, center))
+                if (Contains(hole, centre))
                     return false;
         return true;
     }

OpenNest.Core/Geometry/MaximalRectangles.cs

@@ -19,7 +19,7 @@ public static class MaximalRectangles
     /// <remarks>
     /// The grid has a line through every vertex coordinate plus <paramref name="divisions"/>
     /// evenly spaced lines per axis. A cell is free only when no edge passes through its
-    /// interior and its center is inside the region, so results are exact for regions whose
+    /// interior and its centre is inside the region, so results are exact for regions whose
     /// edges are all horizontal or vertical. Slanted and curved edges are followed as a
     /// staircase: results stay inside, but can fall short of the true maximum by up to about
     /// one cell on each side. Rotate the region to search other rectangle angles.
@@ -64,9 +64,9 @@ public static class MaximalRectangles
         var crossings = new List<double>();
         for (var r = 0; r < rows; r++)
         {
-            // Even-odd scan along the row's center line. No vertex lies on it, and an edge that
+            // Even-odd scan along the row's centre line. No vertex lies on it, and an edge that
             // meets it strictly inside a cell has already marked that cell crossed, so each
-            // uncrossed cell is on the same side as its center.
+            // uncrossed cell is on the same side as its centre.
             var y = (ys[r] + ys[r + 1]) / 2;
             crossings.Clear();
             foreach (var path in paths)
@@ -279,7 +279,7 @@ public static class MaximalRectangles
 
             foreach (var larger in results)
             {
-                if (BoundingBox.IsWithin(box, larger))
+                if (IsContainedIn(box, larger))
                 {
                     dominated = true;
                     break;
@@ -292,4 +292,13 @@ public static class MaximalRectangles
 
         return results;
     }
+
+    private static bool IsContainedIn(Box inner, Box outer)
+    {
+        var eps = Math.Tolerance.Epsilon;
+        return inner.Left >= outer.Left - eps
+            && inner.Right <= outer.Right + eps
+            && inner.Bottom >= outer.Bottom - eps
+            && inner.Top <= outer.Top + eps;
+    }
 }

OpenNest.Core/Geometry/PolyLabel.cs

@@ -17,7 +17,7 @@ namespace OpenNest.Geometry
         /// <summary>
         /// Bounded search for callers that cannot afford refinement along a long thin shape:
         /// stops after about <paramref name="maxCells"/> distance evaluations and returns the best
-        /// cell center so far. When the starting grid would exceed a quarter of the budget it is
+        /// cell centre so far. When the starting grid would exceed a quarter of the budget it is
         /// coarsened so the whole shape is sampled first. The result can lie outside a shape
         /// thinner than the remaining refinement, so callers must check it.
         /// </summary>
@@ -28,16 +28,12 @@ namespace OpenNest.Geometry
         /// A precision proportional to the shape's mean material width (twice the net area over
         /// the total outline length, holes included), so small or slender shapes refine further
         /// than large solid ones. A fixed precision near the shape's size stops at the first
-        /// interior cell. Holes that leave no net area (a second outline mistaken for a hole, so
+        /// interior cell.
-        /// lying outside the first) fall back to the outline alone: a near-zero precision would
-        /// refine a pole ridge, such as a rectangle's centerline, into billions of cells.
         /// </summary>
         public static double ThicknessPrecision(Polygon outer, IList<Polygon> holes = null, double fraction = 0.05)
         {
-            var outerArea = outer.Area();
+            var area = outer.Area();
-            var outerLength = ClosedLength(outer);
+            var length = ClosedLength(outer);
-            var area = outerArea;
-            var length = outerLength;
 
             if (holes != null)
             {
@@ -48,13 +44,6 @@ namespace OpenNest.Geometry
                 }
             }
 
-            // Equal outlines leave rounding noise, not material.
-            if (!(area > outerArea * 1e-6) || !(length > 0))
-            {
-                area = outerArea;
-                length = outerLength;
-            }
-
             if (!(area > 0) || !(length > 0))
                 return 1e-9;
 
@@ -117,7 +106,6 @@ namespace OpenNest.Geometry
             }
 
             var halfCell = cellSize / 2;
-            var boxes = HoleBoxes(holes);
 
             var initial = new List<Cell>();
 
@@ -125,7 +113,7 @@ namespace OpenNest.Geometry
             {
                 for (var y = minY; y < maxY; y += cellSize)
                 {
-                    initial.Add(new Cell(x + halfCell, y + halfCell, halfCell, outer, holes, boxes));
+                    initial.Add(new Cell(x + halfCell, y + halfCell, halfCell, outer, holes));
                     // Far from the origin a step smaller than the coordinate's precision
                     // no longer advances; the grid would never end.
                     if (y + cellSize == y)
@@ -137,7 +125,7 @@ namespace OpenNest.Geometry
 
             initial.Sort((a, b) => b.MaxDist.CompareTo(a.MaxDist));
 
-            var bestCell = GetCentroidCell(outer, holes, boxes);
+            var bestCell = GetCentroidCell(outer, holes);
             evaluatedCells = initial.Count + 1;
 
             for (var i = 0; i < initial.Count; i++)
@@ -169,7 +157,7 @@ namespace OpenNest.Geometry
 
                 halfCell = cell.HalfSize / 2;
 
-                // Far from the origin a half-step may no longer move the center; such a cell
+                // Far from the origin a half-step may no longer move the centre; such a cell
                 // cannot be split, and its identical children would multiply without end.
                 if (cell.X - halfCell == cell.X || cell.X + halfCell == cell.X
                     || cell.Y - halfCell == cell.Y || cell.Y + halfCell == cell.Y)
@@ -177,10 +165,10 @@ namespace OpenNest.Geometry
 
                 var newCells = new[]
                 {
-                    new Cell(cell.X - halfCell, cell.Y - halfCell, halfCell, outer, holes, boxes),
+                    new Cell(cell.X - halfCell, cell.Y - halfCell, halfCell, outer, holes),
-                    new Cell(cell.X + halfCell, cell.Y - halfCell, halfCell, outer, holes, boxes),
+                    new Cell(cell.X + halfCell, cell.Y - halfCell, halfCell, outer, holes),
-                    new Cell(cell.X - halfCell, cell.Y + halfCell, halfCell, outer, holes, boxes),
+                    new Cell(cell.X - halfCell, cell.Y + halfCell, halfCell, outer, holes),
-                    new Cell(cell.X + halfCell, cell.Y + halfCell, halfCell, outer, holes, boxes),
+                    new Cell(cell.X + halfCell, cell.Y + halfCell, halfCell, outer, holes),
                 };
                 evaluatedCells += newCells.Length;
 
@@ -194,7 +182,7 @@ namespace OpenNest.Geometry
             return new Vector(bestCell.X, bestCell.Y);
         }
 
-        private static Cell GetCentroidCell(Polygon outer, IList<Polygon> holes, Box[] boxes)
+        private static Cell GetCentroidCell(Polygon outer, IList<Polygon> holes)
         {
             var area = 0.0;
             var cx = 0.0;
@@ -214,12 +202,12 @@ namespace OpenNest.Geometry
             area *= 0.5;
 
             if (System.Math.Abs(area) < 1e-10)
-                return new Cell(verts[0].X, verts[0].Y, 0, outer, holes, boxes);
+                return new Cell(verts[0].X, verts[0].Y, 0, outer, holes);
 
             cx /= (6 * area);
             cy /= (6 * area);
 
-            return new Cell(cx, cy, 0, outer, holes, boxes);
+            return new Cell(cx, cy, 0, outer, holes);
         }
 
         private static double PointToPolygonDist(double x, double y, Polygon polygon)
@@ -268,7 +256,7 @@ namespace OpenNest.Geometry
             public readonly double Dist;
             public readonly double MaxDist;
 
-            public Cell(double x, double y, double halfSize, Polygon outer, IList<Polygon> holes, Box[] boxes)
+            public Cell(double x, double y, double halfSize, Polygon outer, IList<Polygon> holes)
             {
                 X = x;
                 Y = y;
@@ -281,7 +269,7 @@ namespace OpenNest.Geometry
                 {
                     for (var i = 0; i < holes.Count; i++)
                     {
-                        if (boxes[i].Contains(x, y) && holes[i].ContainsPoint(pt))
+                        if (holes[i].ContainsPoint(pt))
                         {
                             inside = false;
                             break;
@@ -289,7 +277,7 @@ namespace OpenNest.Geometry
                     }
                 }
 
-                Dist = PointToAllEdgesDist(x, y, outer, holes, boxes);
+                Dist = PointToAllEdgesDist(x, y, outer, holes);
 
                 if (!inside)
                     Dist = -Dist;
@@ -302,8 +290,7 @@ namespace OpenNest.Geometry
             double x,
             double y,
             Polygon outer,
-            IList<Polygon> holes,
+            IList<Polygon> holes
-            Box[] boxes
         )
         {
             var minDist = PointToPolygonDist(x, y, outer);
@@ -312,9 +299,6 @@ namespace OpenNest.Geometry
             {
                 for (var i = 0; i < holes.Count; i++)
                 {
-                    // No edge is nearer than its hole's box, so a farther box cannot lower the minimum.
-                    if (boxes[i].Distance(x, y) > minDist)
-                        continue;
                     var d = PointToPolygonDist(x, y, holes[i]);
                     if (d < minDist)
                         minDist = d;
@@ -323,38 +307,5 @@ namespace OpenNest.Geometry
 
             return minDist;
         }
-
-        // Each hole's vertex bounds: a cell skips the containment test outside them and the
-        // edge distances when they are farther than the nearest edge found so far. Both skips
-        // leave the result exactly as without them; parts with many small holes search far faster.
-        private static Box[] HoleBoxes(IList<Polygon> holes)
-        {
-            if (holes == null)
-                return null;
-
-            var boxes = new Box[holes.Count];
-            for (var i = 0; i < holes.Count; i++)
-            {
-                var box = new Box(double.MaxValue, double.MaxValue, double.MinValue, double.MinValue);
-                foreach (var v in holes[i].Vertices)
-                    box = new Box(System.Math.Min(box.MinX, v.X), System.Math.Min(box.MinY, v.Y),
-                        System.Math.Max(box.MaxX, v.X), System.Math.Max(box.MaxY, v.Y));
-                boxes[i] = box;
-            }
-            return boxes;
-        }
-
-        private readonly record struct Box(double MinX, double MinY, double MaxX, double MaxY)
-        {
-            // Inclusive, so a point on a hole's edge is still tested.
-            public bool Contains(double x, double y) => x >= MinX && x <= MaxX && y >= MinY && y <= MaxY;
-
-            public double Distance(double x, double y)
-            {
-                var dx = System.Math.Max(System.Math.Max(MinX - x, x - MaxX), 0);
-                var dy = System.Math.Max(System.Math.Max(MinY - y, y - MaxY), 0);
-                return System.Math.Sqrt(dx * dx + dy * dy);
-            }
-        }
     }
 }

OpenNest.Core/Geometry/Polygon.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using OpenNest.Math;
@@ -120,7 +120,7 @@ namespace OpenNest.Geometry
         /// <returns></returns>
         public List<Line> ToLines()
         {
-            var list = new List<Line>(Vertices.Count);
+            var list = new List<Line>();
 
             if (Vertices.Count < 2)
                 return list;

OpenNest.Core/Geometry/Shape.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -585,8 +585,8 @@ namespace OpenNest.Geometry
             }
 
             if (
-                !EntityEndpoints.TryGet(last.Offset, out _, out var gapStart)
+                !TryGetEnds(last.Offset, out _, out var gapStart)
-                || !EntityEndpoints.TryGet(next.Offset, out var gapEnd, out _)
+                || !TryGetEnds(next.Offset, out var gapEnd, out _)
             )
                 return;
 
@@ -625,7 +625,7 @@ namespace OpenNest.Geometry
             corner = default;
 
             if (
-                !EntityEndpoints.TryGet(last, out _, out corner)
+                !TryGetEnds(last, out _, out corner)
                 || !TryGetTangents(last, out _, out var d1)
                 || !TryGetTangents(next, out var d2, out _)
             )
@@ -637,6 +637,26 @@ namespace OpenNest.Geometry
                 || (side == OffsetSide.Right && cross > OpenNest.Math.Tolerance.Epsilon);
         }
 
+        private static bool TryGetEnds(Entity entity, out Vector start, out Vector end)
+        {
+            switch (entity)
+            {
+                case Line line:
+                    start = line.StartPoint;
+                    end = line.EndPoint;
+                    return true;
+
+                case Arc arc:
+                    start = arc.StartPoint();
+                    end = arc.EndPoint();
+                    return true;
+
+                default:
+                    start = end = default;
+                    return false;
+            }
+        }
+
         /// <summary>
         /// Direction of travel at the start and end of a line or arc.
         /// </summary>
@@ -730,25 +750,64 @@ namespace OpenNest.Geometry
         /// Normalizes to CW winding before offsetting Left (which is outward for CW),
         /// making the method independent of the original contour winding direction.
         /// </summary>
-        internal Shape OffsetOutward(double distance) =>
+        internal Shape OffsetOutward(double distance)
-            OffsetLeftWithWinding(distance, RotationType.CW);
+        {
+            var poly = ToPolygon();
+
+            if (
+                poly == null
+                || poly.Vertices.Count < 3
+                || poly.RotationDirection() == RotationType.CW
+            )
+                return OffsetEntity(distance, OffsetSide.Left) as Shape;
+
+            // Shape is CCW — reverse to CW so Left offset goes outward.
+            var copy = new Shape();
+
+            for (var i = Entities.Count - 1; i >= 0; i--)
+            {
+                switch (Entities[i])
+                {
+                    case Line l:
+                        copy.Entities.Add(new Line(l.EndPoint, l.StartPoint) { Layer = l.Layer });
+                        break;
+                    case Arc a:
+                        copy.Entities.Add(
+                            new Arc(a.Center, a.Radius, a.EndAngle, a.StartAngle, !a.IsReversed)
+                            {
+                                Layer = a.Layer,
+                            }
+                        );
+                        break;
+                    case Circle c:
+                        copy.Entities.Add(
+                            new Circle(c.Center, c.Radius)
+                            {
+                                Layer = c.Layer,
+                                Rotation = RotationType.CW,
+                            }
+                        );
+                        break;
+                }
+            }
+
+            return copy.OffsetEntity(distance, OffsetSide.Left) as Shape;
+        }
 
         /// <summary>
         /// Offsets the shape inward by the given distance.
         /// Normalizes to CCW winding before offsetting Left (which is inward for CCW),
         /// making the method independent of the original contour winding direction.
         /// </summary>
-        internal Shape OffsetInward(double distance) =>
+        internal Shape OffsetInward(double distance)
-            OffsetLeftWithWinding(distance, RotationType.CCW);
-
-        /// <summary>
-        /// Offsets Left after normalizing the contour to <paramref name="winding"/>.
-        /// </summary>
-        private Shape OffsetLeftWithWinding(double distance, RotationType winding)
         {
             var poly = ToPolygon();
 
-            if (poly == null || poly.Vertices.Count < 3 || poly.RotationDirection() == winding)
+            if (
+                poly == null
+                || poly.Vertices.Count < 3
+                || poly.RotationDirection() == RotationType.CCW
+            )
                 return OffsetEntity(distance, OffsetSide.Left) as Shape;
 
             // Create a reversed copy to avoid mutating shared entity objects.
@@ -774,7 +833,7 @@ namespace OpenNest.Geometry
                             new Circle(c.Center, c.Radius)
                             {
                                 Layer = c.Layer,
-                                Rotation = winding,
+                                Rotation = RotationType.CCW,
                             }
                         );
                         break;

OpenNest.Core/Geometry/ShapeBuilder.cs

@@ -64,28 +64,47 @@ namespace OpenNest.Geometry
             if (weldTolerance.HasValue)
                 WeldEndpoints(entityList, weldTolerance.Value);
 
-            // Chain in list order: each shape starts at the first unused entity and takes the
+            while (entityList.Count > 0)
-            // first unused entity, in list order, with an end at its current end. An endpoint
-            // grid finds those candidates without rescanning the whole list at every step.
-            var index = new EndpointIndex(entityList);
-            var used = new bool[entityList.Count];
-            for (var first = 0; first < entityList.Count; first++)
             {
-                if (used[first])
+                var next = entityList[0];
-                    continue;
-
-                var next = entityList[first];
-                used[first] = true;
                 var shape = new Shape();
                 shape.Entities.Add(next);
 
-                var startPoint = EndOf(next);
+                entityList.RemoveAt(0);
+
+                Vector startPoint = new Vector();
                 Entity connected;
 
-                while ((connected = index.TakeConnected(startPoint, entityList, used)) != null)
+                switch (next.Type)
+                {
+                    case EntityType.Arc:
+                        var arc = (Arc)next;
+                        startPoint = arc.EndPoint();
+                        break;
+
+                    case EntityType.Line:
+                        var line = (Line)next;
+                        startPoint = line.EndPoint;
+                        break;
+                }
+
+                while ((connected = GetConnected(startPoint, entityList)) != null)
                 {
                     shape.Entities.Add(connected);
-                    startPoint = EndOf(connected);
+                    entityList.Remove(connected);
+
+                    switch (connected.Type)
+                    {
+                        case EntityType.Arc:
+                            var arc = (Arc)connected;
+                            startPoint = arc.EndPoint();
+                            break;
+
+                        case EntityType.Line:
+                            var line = (Line)connected;
+                            startPoint = line.EndPoint;
+                            break;
+                    }
                 }
 
                 shape.UpdateBounds();
@@ -186,131 +205,6 @@ namespace OpenNest.Geometry
             }
         }
 
-        private static Vector EndOf(Entity entity) => entity.Type switch
-        {
-            EntityType.Arc => ((Arc)entity).EndPoint(),
-            EntityType.Line => ((Line)entity).EndPoint,
-            _ => new Vector(),
-        };
-
-        // Matches GetConnected entity by entity: true and reversed when only its end matches.
-        private static bool Connects(Entity entity, Vector pt, double tol)
-        {
-            switch (entity.Type)
-            {
-                case EntityType.Arc:
-                    var arc = (Arc)entity;
-                    if (arc.StartPoint().DistanceTo(pt) <= tol)
-                        return true;
-                    if (arc.EndPoint().DistanceTo(pt) <= tol)
-                    {
-                        arc.Reverse();
-                        return true;
-                    }
-                    return false;
-
-                case EntityType.Line:
-                    var line = (Line)entity;
-                    if (line.StartPoint.DistanceTo(pt) <= tol)
-                        return true;
-                    if (line.EndPoint.DistanceTo(pt) <= tol)
-                    {
-                        line.Reverse();
-                        return true;
-                    }
-                    return false;
-
-                default:
-                    return false;
-            }
-        }
-
-        /// <summary>
-        /// Entity positions by the grid cells of their endpoints, cells twice the chain
-        /// tolerance wide, so every endpoint within tolerance of a point lies in its cell or a
-        /// neighbor, rounding included. Reversing an entity swaps its endpoints, so the index stays valid.
-        /// Endpoints too far out or not finite to place are checked on every query.
-        /// </summary>
-        private sealed class EndpointIndex
-        {
-            private const double CellSize = 2 * Tolerance.ChainTolerance;
-            private const double MaxCell = 1e15;
-            private readonly Dictionary<(long, long), List<int>> cells = new();
-            private readonly List<int> unplaced = new();
-            private readonly List<int> candidates = new();
-
-            public EndpointIndex(List<Entity> entities)
-            {
-                for (var i = 0; i < entities.Count; i++)
-                {
-                    var (start, end) = GetEndpoints(entities[i]);
-                    if (!Place(i, start) | !Place(i, end))
-                        unplaced.Add(i);
-                }
-            }
-
-            private bool Place(int i, Vector point)
-            {
-                if (!TryCell(point, out var cell))
-                    return false;
-                if (!cells.TryGetValue(cell, out var list))
-                    cells[cell] = list = new List<int>();
-                if (list.Count == 0 || list[^1] != i)
-                    list.Add(i);
-                return true;
-            }
-
-            private static bool TryCell(Vector point, out (long, long) cell)
-            {
-                var x = System.Math.Floor(point.X / CellSize);
-                var y = System.Math.Floor(point.Y / CellSize);
-                cell = default;
-                if (!(System.Math.Abs(x) < MaxCell) || !(System.Math.Abs(y) < MaxCell))
-                    return false;
-                cell = ((long)x, (long)y);
-                return true;
-            }
-
-            /// <summary>The first unused entity, in list order, that connects to <paramref name="pt"/>; marked used.</summary>
-            public Entity TakeConnected(Vector pt, List<Entity> entities, bool[] used)
-            {
-                candidates.Clear();
-                if (TryCell(pt, out var cell))
-                {
-                    for (var dx = -1L; dx <= 1; dx++)
-                    {
-                        for (var dy = -1L; dy <= 1; dy++)
-                        {
-                            if (cells.TryGetValue((cell.Item1 + dx, cell.Item2 + dy), out var list))
-                                candidates.AddRange(list);
-                        }
-                    }
-                    candidates.AddRange(unplaced);
-                }
-                else
-                {
-                    // A point that cannot be placed is compared with every entity, as before.
-                    for (var i = 0; i < entities.Count; i++)
-                        candidates.Add(i);
-                }
-
-                candidates.Sort();
-                var previous = -1;
-                foreach (var i in candidates)
-                {
-                    if (i == previous || used[i])
-                        continue;
-                    previous = i;
-                    if (Connects(entities[i], pt, Tolerance.ChainTolerance))
-                    {
-                        used[i] = true;
-                        return entities[i];
-                    }
-                }
-                return null;
-            }
-        }
-
         internal static Entity GetConnected(Vector pt, IEnumerable<Entity> geometry)
         {
             var tol = Tolerance.ChainTolerance;

OpenNest.Core/Geometry/ShapeProfile.cs

@@ -15,22 +15,10 @@ namespace OpenNest.Geometry
             Update(entities);
         }
 
-        private ShapeProfile()
+        private void Update(List<Entity> entities)
         {
-        }
+            var shapes = ShapeBuilder.GetShapes(entities);
 
-        /// <summary>A profile of shapes already built, for callers that need them too; at least one.</summary>
-        public static ShapeProfile FromShapes(List<Shape> shapes)
-        {
-            var profile = new ShapeProfile();
-            profile.Update(shapes);
-            return profile;
-        }
-
-        private void Update(List<Entity> entities) => Update(ShapeBuilder.GetShapes(entities));
-
-        private void Update(List<Shape> shapes)
-        {
             Perimeter = shapes[0];
             Cutouts = new List<Shape>();
 

OpenNest.Core/Geometry/SlideBand.cs

@@ -1,217 +0,0 @@
-namespace OpenNest.Geometry
-{
-    /// <summary>
-    /// Conservative perpendicular-extent tests for slides along an exact axis direction.
-    /// A ray parallel to an axis can only meet an entity whose extent across that axis holds
-    /// the ray's perpendicular coordinate. Each test answers "may emit" whenever the matching
-    /// kernel could still report a hit: margins cover the kernel's own tolerances and its
-    /// floating-point rounding. A pair with any coordinate or radius that is NaN, infinite
-    /// or beyond <see cref="CoordinateLimit"/> is always kept, because the kernels' products
-    /// can then become NaN and still emit.
-    /// </summary>
-    internal static class SlideBand
-    {
-        internal enum Axis
-        {
-            None,
-
-            /// <summary>Push along ±X; the perpendicular coordinate is Y.</summary>
-            PerpendicularY,
-
-            /// <summary>Push along ±Y; the perpendicular coordinate is X.</summary>
-            PerpendicularX,
-        }
-
-        /// <summary>
-        /// Largest coordinate or radius magnitude the tests reason about. Below it every
-        /// square and product in the kernels stays finite (the squares stay below 1e301).
-        /// </summary>
-        internal const double CoordinateLimit = 1e150;
-
-        // RayLine accepts a segment parameter in [-Eps, 1 + Eps], which reaches Eps of the
-        // segment's perpendicular span past either end. Twice that is kept: the computed
-        // parameter differs from the exact one by a few ulps, far less than the extra Eps.
-        // No absolute slack is needed: the kernels translate entities with the same
-        // expressions as these tests, and a circle point c + r·sinθ rounds monotonically, so
-        // it never lies outside fl(c ± r).
-        internal const double SpanSlack = 2 * Math.Tolerance.Epsilon;
-
-        // SolveRayCircle accepts a nonnegative discriminant b² − 4ac. For an axis ray that is
-        // 4(r² − oy²) up to rounding of terms of size ox² + oy² + r², so a hit is possible when
-        // oy² ≤ r² + ε(1 + ox² + oy² + r²). This ε is hundreds of ulps; the absolute 1 is a
-        // floor for squares that underflow.
-        internal const double QuadraticSlack = 1e-13;
-
-        public static Axis For(double dirX, double dirY)
-        {
-            if (dirY == 0 && (dirX == 1 || dirX == -1))
-                return Axis.PerpendicularY;
-            if (dirX == 0 && (dirY == 1 || dirY == -1))
-                return Axis.PerpendicularX;
-            return Axis.None;
-        }
-
-        /// <summary>
-        /// False only when <see cref="SlideEvents.Ray"/> from (vx, vy) along the axis cannot
-        /// emit against <paramref name="entity"/> translated by (dx, dy).
-        /// </summary>
-        public static bool RayMayHit(
-            Axis axis,
-            double vx,
-            double vy,
-            Entity entity,
-            double dx,
-            double dy
-        )
-        {
-            if (!Bounded(vx) || !Bounded(vy))
-                return true;
-
-            switch (entity)
-            {
-                case Line line:
-                    {
-                        var p1x = line.pt1.X + dx;
-                        var p1y = line.pt1.Y + dy;
-                        var p2x = line.pt2.X + dx;
-                        var p2y = line.pt2.Y + dy;
-                        if (!Bounded(p1x) || !Bounded(p1y) || !Bounded(p2x) || !Bounded(p2y))
-                            return true;
-                        return PointMayReachSegment(
-                            Perp(axis, vx, vy),
-                            Perp(axis, p1x, p1y),
-                            Perp(axis, p2x, p2y)
-                        );
-                    }
-                case Arc arc:
-                    return PointMayReachCircle(
-                        axis,
-                        vx,
-                        vy,
-                        arc.Center.X + dx,
-                        arc.Center.Y + dy,
-                        arc.Radius
-                    );
-                case Circle circle:
-                    return PointMayReachCircle(
-                        axis,
-                        vx,
-                        vy,
-                        circle.Center.X + dx,
-                        circle.Center.Y + dy,
-                        circle.Radius
-                    );
-                default:
-                    return true;
-            }
-        }
-
-        /// <summary>
-        /// False only when no point of the circle (cx, cy, r) can reach the segment along the
-        /// axis, which is what <see cref="SlideEvents.ArcToLine"/> tests for each arc/line pair.
-        /// </summary>
-        public static bool CircleMayReachLine(
-            Axis axis,
-            double cx,
-            double cy,
-            double r,
-            double p1x,
-            double p1y,
-            double p2x,
-            double p2y
-        )
-        {
-            if (
-                !Bounded(cx) || !Bounded(cy) || !Bounded(r)
-                || !Bounded(p1x) || !Bounded(p1y) || !Bounded(p2x) || !Bounded(p2y)
-            )
-                return true;
-
-            var c = Perp(axis, cx, cy);
-            var a = Perp(axis, p1x, p1y);
-            var b = Perp(axis, p2x, p2y);
-            var lo = System.Math.Min(a, b);
-            var hi = System.Math.Max(a, b);
-            var radius = System.Math.Abs(r);
-            var margin = SpanSlack * (hi - lo);
-            if (c + radius < lo - margin || c - radius > hi + margin)
-                return false;
-            return true;
-        }
-
-        /// <summary>
-        /// False only when two circles sliding along the axis can never touch, the condition
-        /// <see cref="SlideEvents.CurveTangency"/> solves for both external and internal contact.
-        /// </summary>
-        public static bool CirclesMayTouch(
-            Axis axis,
-            double movingCx,
-            double movingCy,
-            double movingR,
-            double stationaryCx,
-            double stationaryCy,
-            double stationaryR
-        )
-        {
-            if (
-                !Bounded(movingCx) || !Bounded(movingCy) || !Bounded(movingR)
-                || !Bounded(stationaryCx) || !Bounded(stationaryCy) || !Bounded(stationaryR)
-            )
-                return true;
-
-            var radius = System.Math.Abs(movingR) + System.Math.Abs(stationaryR);
-            return CenterMayReach(
-                Para(axis, movingCx, movingCy) - Para(axis, stationaryCx, stationaryCy),
-                Perp(axis, movingCx, movingCy) - Perp(axis, stationaryCx, stationaryCy),
-                radius
-            );
-        }
-
-        private static bool PointMayReachSegment(double v, double a, double b)
-        {
-            var lo = System.Math.Min(a, b);
-            var hi = System.Math.Max(a, b);
-            var margin = SpanSlack * (hi - lo);
-            if (v < lo - margin || v > hi + margin)
-                return false;
-            return true;
-        }
-
-        private static bool PointMayReachCircle(
-            Axis axis,
-            double vx,
-            double vy,
-            double cx,
-            double cy,
-            double r
-        )
-        {
-            if (!Bounded(cx) || !Bounded(cy) || !Bounded(r))
-                return true;
-            return CenterMayReach(
-                Para(axis, vx, vy) - Para(axis, cx, cy),
-                Perp(axis, vx, vy) - Perp(axis, cx, cy),
-                r
-            );
-        }
-
-        private static bool CenterMayReach(double ox, double oy, double r)
-        {
-            var oy2 = oy * oy;
-            var r2 = r * r;
-            var slack = QuadraticSlack * (1 + ox * ox + oy2 + r2);
-            if (oy2 > r2 + slack)
-                return false;
-            return true;
-        }
-
-        /// <summary>False for NaN, infinities and magnitudes beyond the coordinate limit.</summary>
-        private static bool Bounded(double value) => System.Math.Abs(value) <= CoordinateLimit;
-
-        internal static double Perp(Axis axis, double x, double y) =>
-            axis == Axis.PerpendicularY ? y : x;
-
-        internal static double Para(Axis axis, double x, double y) =>
-            axis == Axis.PerpendicularY ? x : y;
-    }
-}

OpenNest.Core/Geometry/SlideBandIndex.cs

@@ -1,513 +0,0 @@
-#nullable enable
-using System.Collections.Generic;
-
-namespace OpenNest.Geometry
-{
-    /// <summary>
-    /// Buckets entity indices by their perpendicular extent for one axis-aligned slide, so a
-    /// band query returns, in ascending entity order, a superset of the entities the
-    /// <see cref="SlideBand"/> tests accept. Callers still apply those exact tests; the index
-    /// only avoids visiting entities that cannot pass them.
-    /// </summary>
-    /// <remarks>
-    /// Each extent is the exact acceptance bound of the matching <see cref="SlideBand"/> test,
-    /// widened by a reach that covers the quadratic slack of ray-circle and curve-curve tests
-    /// (which grows with the along-axis distance) plus rounding. Bucket numbers are a
-    /// monotone function of the coordinate, so a value inside an extent always lands in one of
-    /// the extent's buckets.
-    /// </remarks>
-    internal sealed class SlideBandIndex
-    {
-        /// <summary>Entities of one kind an index holds.</summary>
-        internal enum Kind
-        {
-            All,
-            Lines,
-            Curves,
-        }
-
-        // Below this many entities a plain scan is as cheap as building buckets.
-        internal const int MinimumEntities = 24;
-
-        private const int MaximumBuckets = 512;
-
-        // Merging more sorted bucket lists than this by repeated minimum is slower than a sort.
-        private const int MaximumMergedBuckets = 16;
-
-        private readonly double min;
-        private readonly double scale;
-        private readonly int bucketCount;
-        private readonly int[] starts;
-        private readonly int[] items;
-
-        private SlideBandIndex(double min, double scale, int bucketCount, int[] starts, int[] items)
-        {
-            this.min = min;
-            this.scale = scale;
-            this.bucketCount = bucketCount;
-            this.starts = starts;
-            this.items = items;
-        }
-
-        /// <summary>
-        /// The widening every extent needs on top of its own exact bound: 2√ε·(1 + separation),
-        /// where separation is twice the largest along-axis coordinate (the quadratic slack),
-        /// plus a relative rounding term.
-        /// NaN when a coordinate is nonfinite or beyond <see cref="SlideBand.CoordinateLimit"/>,
-        /// where the band tests keep every pair and an index could not stand in for them.
-        /// </summary>
-        public static double Reach(double maxAbsAlong, double maxAbsPerpendicular)
-        {
-            if (
-                !(maxAbsAlong <= SlideBand.CoordinateLimit)
-                || !(maxAbsPerpendicular <= SlideBand.CoordinateLimit)
-            )
-                return double.NaN;
-            var separation = 2 * maxAbsAlong;
-            // The second term is headroom for rounding of the extents and the curve tests'
-            // 2ε·|r|; no test case needs it today, but it costs nothing measurable.
-            return 2 * System.Math.Sqrt(SlideBand.QuadraticSlack) * (1 + separation)
-                + 1e-12 * (1 + separation + maxAbsPerpendicular);
-        }
-
-        /// <summary>
-        /// A curve's half-width before widening, |r|. The quadratic tests accept at most
-        /// |oy| ≤ |r|·(1 + 2ε) + 2√ε·(1 + |ox|) with ε = QuadraticSlack; the reach holds both the
-        /// second term and the first one's 2ε·|r|, since its rounding term is 1e-12 times a bound
-        /// that includes every radius.
-        /// </summary>
-        public static double CurveReach(double r) => System.Math.Abs(r);
-
-        /// <summary>
-        /// Indexes the entities of <paramref name="kind"/> in <paramref name="entities"/>
-        /// translated by (dx, dy), or returns null when the list is small or the geometry or
-        /// reach is not usable.
-        /// </summary>
-        public static SlideBandIndex? Build(
-            SlideBand.Axis axis,
-            List<Entity> entities,
-            double dx,
-            double dy,
-            double reach,
-            Kind kind
-        )
-        {
-            var count = entities.Count;
-            if (count < MinimumEntities || !double.IsFinite(reach) || reach < 0)
-                return null;
-
-            var lo = new double[count];
-            var hi = new double[count];
-            var indexed = new bool[count];
-            var members = 0;
-            var min = double.PositiveInfinity;
-            var max = double.NegativeInfinity;
-            for (var i = 0; i < count; i++)
-            {
-                if (!TryExtent(axis, entities[i], dx, dy, kind, out var a, out var b))
-                    continue;
-                a -= reach;
-                b += reach;
-                if (!double.IsFinite(a) || !double.IsFinite(b))
-                    return null;
-                lo[i] = a;
-                hi[i] = b;
-                indexed[i] = true;
-                members++;
-                if (a < min)
-                    min = a;
-                if (b > max)
-                    max = b;
-            }
-
-            if (members == 0)
-                return new SlideBandIndex(0, 0, 1, new int[2], System.Array.Empty<int>());
-
-            var buckets = System.Math.Min(MaximumBuckets, members);
-            var span = max - min;
-            var scale = span > 0 ? buckets / span : 0;
-            if (!double.IsFinite(scale) || scale <= 0)
-            {
-                scale = 0;
-                buckets = 1;
-            }
-
-            var shape = new SlideBandIndex(
-                min,
-                scale,
-                buckets,
-                System.Array.Empty<int>(),
-                System.Array.Empty<int>()
-            );
-            var next = new int[buckets + 1];
-            for (var i = 0; i < count; i++)
-            {
-                if (!indexed[i])
-                    continue;
-                var last = shape.Bucket(hi[i]);
-                for (var b = shape.Bucket(lo[i]); b <= last; b++)
-                    next[b + 1]++;
-            }
-
-            for (var b = 0; b < buckets; b++)
-                next[b + 1] += next[b];
-            var starts = (int[])next.Clone();
-            var items = new int[next[buckets]];
-            for (var i = 0; i < count; i++)
-            {
-                if (!indexed[i])
-                    continue;
-                var last = shape.Bucket(hi[i]);
-                for (var b = shape.Bucket(lo[i]); b <= last; b++)
-                    items[next[b]++] = i;
-            }
-
-            return new SlideBandIndex(min, scale, buckets, starts, items);
-        }
-
-        /// <summary>
-        /// Entities whose extent may contain <paramref name="value"/>, as the item positions
-        /// [start, end), ascending. Empty when the value lies below every extent; false for a
-        /// nonfinite value (scan everything).
-        /// </summary>
-        public bool TryPoint(double value, out int start, out int end)
-        {
-            start = end = 0;
-            if (!double.IsFinite(value))
-                return false;
-            if (value < min)
-                return true;
-            var b = Bucket(value);
-            start = starts[b];
-            end = starts[b + 1];
-            return true;
-        }
-
-        /// <summary>
-        /// Entities whose extent may overlap [<paramref name="from"/>, <paramref name="to"/>],
-        /// ascending and without repeats, written to <paramref name="result"/>. False for a
-        /// nonfinite interval (scan everything).
-        /// </summary>
-        public bool TryRange(double from, double to, List<int> result)
-        {
-            result.Clear();
-            if (!double.IsFinite(from) || !double.IsFinite(to))
-                return false;
-            if (to < min)
-                return true;
-
-            var first = Bucket(from);
-            var last = Bucket(to);
-            if (first == last)
-            {
-                for (var k = starts[first]; k < starts[first + 1]; k++)
-                    result.Add(items[k]);
-                return true;
-            }
-
-            var lists = last - first + 1;
-            if (lists > MaximumMergedBuckets)
-            {
-                for (var k = starts[first]; k < starts[last + 1]; k++)
-                    result.Add(items[k]);
-                result.Sort();
-                Deduplicate(result);
-                return true;
-            }
-
-            // Each bucket list is ascending: merge them by repeated minimum, dropping repeats.
-            System.Span<int> heads = stackalloc int[MaximumMergedBuckets];
-            for (var b = 0; b < lists; b++)
-                heads[b] = starts[first + b];
-            var previous = -1;
-            while (true)
-            {
-                var best = int.MaxValue;
-                var source = -1;
-                for (var b = 0; b < lists; b++)
-                {
-                    var head = heads[b];
-                    if (head < starts[first + b + 1] && items[head] < best)
-                    {
-                        best = items[head];
-                        source = b;
-                    }
-                }
-                if (source < 0)
-                    return true;
-                heads[source]++;
-                if (best != previous)
-                    result.Add(best);
-                previous = best;
-            }
-        }
-
-        public int Item(int position) => items[position];
-
-        private static void Deduplicate(List<int> sorted)
-        {
-            var write = 0;
-            for (var k = 0; k < sorted.Count; k++)
-            {
-                if (write > 0 && sorted[write - 1] == sorted[k])
-                    continue;
-                sorted[write++] = sorted[k];
-            }
-            sorted.RemoveRange(write, sorted.Count - write);
-        }
-
-        /// <summary>Monotone in <paramref name="value"/>, clamped to the bucket range.</summary>
-        private int Bucket(double value)
-        {
-            if (scale == 0)
-                return 0;
-            var b = (value - min) * scale;
-            if (!(b >= 0))
-                return 0;
-            if (b >= bucketCount)
-                return bucketCount - 1;
-            return (int)b;
-        }
-
-        /// <summary>
-        /// The exact acceptance bound of the entity's <see cref="SlideBand"/> tests before
-        /// widening: a line's span with its RayLine slack, or a curve's circle ±|r| (its slack
-        /// is in the reach). False for entity types no slide kernel emits for, or not of
-        /// <paramref name="kind"/>.
-        /// </summary>
-        private static bool TryExtent(
-            SlideBand.Axis axis,
-            Entity entity,
-            double dx,
-            double dy,
-            Kind kind,
-            out double lo,
-            out double hi
-        )
-        {
-            switch (entity)
-            {
-                case Line line when kind != Kind.Curves:
-                    {
-                        var a = SlideBand.Perp(axis, line.pt1.X + dx, line.pt1.Y + dy);
-                        var b = SlideBand.Perp(axis, line.pt2.X + dx, line.pt2.Y + dy);
-                        var low = System.Math.Min(a, b);
-                        var high = System.Math.Max(a, b);
-                        var margin = SlideBand.SpanSlack * (high - low);
-                        lo = low - margin;
-                        hi = high + margin;
-                        return true;
-                    }
-                case Arc arc when kind != Kind.Lines:
-                    return CurveExtent(
-                        axis,
-                        arc.Center.X + dx,
-                        arc.Center.Y + dy,
-                        arc.Radius,
-                        out lo,
-                        out hi
-                    );
-                case Circle circle when kind != Kind.Lines:
-                    return CurveExtent(
-                        axis,
-                        circle.Center.X + dx,
-                        circle.Center.Y + dy,
-                        circle.Radius,
-                        out lo,
-                        out hi
-                    );
-                default:
-                    lo = hi = 0;
-                    return false;
-            }
-        }
-
-        private static bool CurveExtent(
-            SlideBand.Axis axis,
-            double cx,
-            double cy,
-            double r,
-            out double lo,
-            out double hi
-        )
-        {
-            var c = SlideBand.Perp(axis, cx, cy);
-            var radius = CurveReach(r);
-            lo = c - radius;
-            hi = c + radius;
-            return true;
-        }
-
-        /// <summary>
-        /// Raises the largest |along| and |perpendicular| coordinate (perpendicular plus radius
-        /// for curves) of translated vertices, line ends and curve centres; used to size
-        /// <see cref="Reach"/>. A NaN propagates. Returns the number of curves seen.
-        /// </summary>
-        public static int Measure(
-            SlideBand.Axis axis,
-            List<Entity> entities,
-            Vector[] vertices,
-            double dx,
-            double dy,
-            ref double maxAlong,
-            ref double maxPerpendicular
-        )
-        {
-            var curves = 0;
-            for (var i = 0; i < vertices.Length; i++)
-            {
-                var v = vertices[i];
-                Accumulate(axis, v.X + dx, v.Y + dy, 0, ref maxAlong, ref maxPerpendicular);
-            }
-            for (var i = 0; i < entities.Count; i++)
-            {
-                switch (entities[i])
-                {
-                    case Line line:
-                        Accumulate(
-                            axis,
-                            line.pt1.X + dx,
-                            line.pt1.Y + dy,
-                            0,
-                            ref maxAlong,
-                            ref maxPerpendicular
-                        );
-                        Accumulate(
-                            axis,
-                            line.pt2.X + dx,
-                            line.pt2.Y + dy,
-                            0,
-                            ref maxAlong,
-                            ref maxPerpendicular
-                        );
-                        break;
-                    case Arc arc:
-                        curves++;
-                        Accumulate(
-                            axis,
-                            arc.Center.X + dx,
-                            arc.Center.Y + dy,
-                            arc.Radius,
-                            ref maxAlong,
-                            ref maxPerpendicular
-                        );
-                        break;
-                    case Circle circle:
-                        curves++;
-                        Accumulate(
-                            axis,
-                            circle.Center.X + dx,
-                            circle.Center.Y + dy,
-                            circle.Radius,
-                            ref maxAlong,
-                            ref maxPerpendicular
-                        );
-                        break;
-                }
-            }
-            return curves;
-        }
-
-        private static void Accumulate(
-            SlideBand.Axis axis,
-            double x,
-            double y,
-            double r,
-            ref double maxAlong,
-            ref double maxPerpendicular
-        )
-        {
-            var along = System.Math.Abs(SlideBand.Para(axis, x, y));
-            var perpendicular = System.Math.Abs(SlideBand.Perp(axis, x, y)) + System.Math.Abs(r);
-            // Written so a NaN propagates instead of being ignored by Math.Max.
-            maxAlong = along > maxAlong || double.IsNaN(along) ? along : maxAlong;
-            maxPerpendicular = perpendicular > maxPerpendicular || double.IsNaN(perpendicular)
-                ? perpendicular
-                : maxPerpendicular;
-        }
-    }
-
-    /// <summary>
-    /// The band indexes one <see cref="EntitySlideEvents"/> enumeration uses, built only for
-    /// the phases that have work: both sides for vertex rays, the line-only side an arc of the
-    /// other side queries, and the stationary curves the moving curves query.
-    /// </summary>
-    internal sealed class SlideBandIndexes
-    {
-        public SlideBandIndex? Stationary { get; private init; }
-
-        public SlideBandIndex? Moving { get; private init; }
-
-        public SlideBandIndex? StationaryLines { get; private init; }
-
-        public SlideBandIndex? MovingLines { get; private init; }
-
-        public SlideBandIndex? StationaryCurves { get; private init; }
-
-        /// <summary>Scratch list for range queries.</summary>
-        public List<int> Candidates { get; } = new();
-
-        /// <summary>
-        /// Null when neither side is large enough to index or a coordinate is unusable.
-        /// </summary>
-        public static SlideBandIndexes? Build(
-            SlideBand.Axis axis,
-            List<Entity> moving,
-            Vector[] movingVertices,
-            double movingDx,
-            double movingDy,
-            List<Entity> stationary,
-            Vector[] stationaryVertices,
-            bool arcToLine
-        )
-        {
-            if (
-                stationary.Count < SlideBandIndex.MinimumEntities
-                && moving.Count < SlideBandIndex.MinimumEntities
-            )
-                return null;
-
-            double along = 0,
-                perpendicular = 0;
-            var stationaryCurves = SlideBandIndex.Measure(
-                axis,
-                stationary,
-                stationaryVertices,
-                0,
-                0,
-                ref along,
-                ref perpendicular
-            );
-            var movingCurves = SlideBandIndex.Measure(
-                axis,
-                moving,
-                movingVertices,
-                movingDx,
-                movingDy,
-                ref along,
-                ref perpendicular
-            );
-            var reach = SlideBandIndex.Reach(along, perpendicular);
-            if (!double.IsFinite(reach))
-                return null;
-
-            var all = SlideBandIndex.Kind.All;
-            var lines = SlideBandIndex.Kind.Lines;
-            var curves = SlideBandIndex.Kind.Curves;
-            return new SlideBandIndexes
-            {
-                Stationary = SlideBandIndex.Build(axis, stationary, 0, 0, reach, all),
-                Moving = SlideBandIndex.Build(axis, moving, movingDx, movingDy, reach, all),
-                StationaryLines = arcToLine && movingCurves > 0
-                    ? SlideBandIndex.Build(axis, stationary, 0, 0, reach, lines)
-                    : null,
-                MovingLines = arcToLine && stationaryCurves > 0
-                    ? SlideBandIndex.Build(axis, moving, movingDx, movingDy, reach, lines)
-                    : null,
-                StationaryCurves = movingCurves > 0 && stationaryCurves > 0
-                    ? SlideBandIndex.Build(axis, stationary, 0, 0, reach, curves)
-                    : null,
-            };
-        }
-    }
-}

OpenNest.Core/Geometry/SlideContact.cs

@@ -37,15 +37,10 @@ namespace OpenNest.Geometry
         internal const double IncidenceTolerance = 1e-7;
 
         // Drawing data fixes arc centers to finite precision, so a tangent joint's arc end
-        // can sit a little past its neighbor's end. A contact this close to a joint takes
+        // can sit a little past its neighbour's end. A contact this close to a joint takes
-        // the joint's tangents; otherwise the neighbor reads as a second boundary there.
+        // the joint's tangents; otherwise the neighbour reads as a second boundary there.
         internal const double JointTolerance = 1e-6;
 
-        // Loops are recovered with ShapeBuilder's chaining tolerance: a source contour that
-        // closes within it (PEP rounding leaves 1e-6 gaps) is a loop everywhere else, and an
-        // unrecovered loop leaves every contact with the whole part unresolved and blocking.
-        internal const double ChainTolerance = Tolerance.ChainTolerance;
-
         private readonly List<Entity> entities;
         private readonly int[] loopOf;
         private readonly int[] previous;
@@ -88,11 +83,11 @@ namespace OpenNest.Geometry
                 }
                 else
                 {
-                    if (!EntityEndpoints.TryGet(entities[i], out var start, out _))
+                    if (!TryEndpoints(entities[i], out var start, out _))
                         return Unresolved(entities);
 
                     var closed = false;
-                    while (i < count && EntityEndpoints.TryGet(entities[i], out _, out var end))
+                    while (i < count && TryEndpoints(entities[i], out _, out var end))
                     {
                         // A lone closed arc is a loop; a lone line cannot be, even when it
                         // has zero length and so ends where it starts.
@@ -105,7 +100,7 @@ namespace OpenNest.Geometry
 
                         if (
                             i + 1 >= count
-                            || !EntityEndpoints.TryGet(entities[i + 1], out var nextStart, out _)
+                            || !TryEndpoints(entities[i + 1], out var nextStart, out _)
                             || !Near(nextStart, end)
                         )
                             break;
@@ -263,11 +258,11 @@ namespace OpenNest.Geometry
         }
 
         private bool StartsNear(int index, Vector point) =>
-            EntityEndpoints.TryGet(entities[index], out var start, out _)
+            TryEndpoints(entities[index], out var start, out _)
             && start.DistanceTo(point) <= JointTolerance;
 
         private bool EndsNear(int index, Vector point) =>
-            EntityEndpoints.TryGet(entities[index], out _, out var end)
+            TryEndpoints(entities[index], out _, out var end)
             && end.DistanceTo(point) <= JointTolerance;
 
         private bool InRun(int index, int first, int last)
@@ -360,7 +355,25 @@ namespace OpenNest.Geometry
             }
         }
 
-        private static bool Near(Vector a, Vector b) => a.DistanceTo(b) <= ChainTolerance;
+        private static bool TryEndpoints(Entity entity, out Vector start, out Vector end)
+        {
+            switch (entity)
+            {
+                case Line line:
+                    start = line.pt1;
+                    end = line.pt2;
+                    return true;
+                case Arc arc:
+                    start = arc.StartPoint();
+                    end = arc.EndPoint();
+                    return true;
+                default:
+                    start = end = new Vector();
+                    return false;
+            }
+        }
+
+        private static bool Near(Vector a, Vector b) => a.DistanceTo(b) <= IncidenceTolerance;
 
         private static double SignedArea(List<Entity> entities, int first, int last)
         {
@@ -693,16 +706,6 @@ namespace OpenNest.Geometry
     {
         internal const double AngleTolerance = 1e-7;
 
-        // Rounded arc centers tilt a joint's tangents: a gap g at the end of an arc of
-        // radius r turns its end tangent by about g / r (1.6e-5 for a 2e-6 gap on a 5/32"
-        // fillet), so two boundaries that touch along a shared edge give a cone a hair wider
-        // than a half-plane. A cone wider than a half-plane by at most this slack is read as
-        // a half-plane whose boundary rays carry that much noise: directions within the
-        // excess of a ray are tangential. A direction admitted that way can enter material
-        // by at most travel x excess at this contact, and every other contact of the slide
-        // is still classified on its own. Wider cones mean real overlap and block.
-        internal const double TangentSlack = 1e-4;
-
         // Reflex sectors are split into two overlapping convex halves; the overlap keeps
         // the split ray in the interior of the union.
         internal const double SplitOverlap = 1e-3;
@@ -756,7 +759,6 @@ namespace OpenNest.Geometry
             var stationaryPieces = Split(stationaryStart, stationaryWidth);
             var movingPieces = Split(movingStart + System.Math.PI, movingWidth);
             var onBoundary = false;
-            var rayTolerance = AngleTolerance;
 
             foreach (var s in stationaryPieces)
             {
@@ -765,35 +767,30 @@ namespace OpenNest.Geometry
                     if (!TryHull(s, m, out var hullStart, out var hullWidth))
                         return true;
 
-                    // A cone just past a half-plane is a noisy half-plane: widen its
-                    // boundary rays by the excess (see TangentSlack).
-                    var tolerance = AngleTolerance + System.Math.Max(0, hullWidth - System.Math.PI);
-                    rayTolerance = System.Math.Max(rayTolerance, tolerance);
-
                     var offset = Angle.NormalizeRad(direction - hullStart);
-                    if (offset > tolerance && offset < hullWidth - tolerance)
+                    if (offset > AngleTolerance && offset < hullWidth - AngleTolerance)
                         return true;
 
                     if (
-                        offset <= tolerance
+                        offset <= AngleTolerance
-                        || offset >= Angle.TwoPI - tolerance
+                        || offset >= Angle.TwoPI - AngleTolerance
-                        || System.Math.Abs(offset - hullWidth) <= tolerance
+                        || System.Math.Abs(offset - hullWidth) <= AngleTolerance
                     )
                         onBoundary = true;
                 }
             }
 
             return onBoundary && (
-                stationaryStartConcave && SameRay(direction, stationaryStart, rayTolerance)
+                stationaryStartConcave && SameRay(direction, stationaryStart)
-                || stationaryEndConcave && SameRay(direction, stationaryStart + stationaryWidth, rayTolerance)
+                || stationaryEndConcave && SameRay(direction, stationaryStart + stationaryWidth)
-                || movingStartConcave && SameRay(direction, movingStart + System.Math.PI, rayTolerance)
+                || movingStartConcave && SameRay(direction, movingStart + System.Math.PI)
-                || movingEndConcave && SameRay(direction, movingStart + movingWidth + System.Math.PI, rayTolerance));
+                || movingEndConcave && SameRay(direction, movingStart + movingWidth + System.Math.PI));
         }
 
-        private static bool SameRay(double a, double b, double tolerance)
+        private static bool SameRay(double a, double b)
         {
             var offset = Angle.NormalizeRad(a - b);
-            return offset <= tolerance || offset >= Angle.TwoPI - tolerance;
+            return offset <= AngleTolerance || offset >= Angle.TwoPI - AngleTolerance;
         }
 
         private static (double Start, double Width)[] Split(double start, double width)
@@ -810,9 +807,7 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Convex cone generated by two convex sectors. False when it is the whole plane;
+        /// Convex cone generated by two convex sectors. False when it is the whole plane.
-        /// a cone wider than a half-plane by no more than <see cref="TangentSlack"/> is
-        /// kept as a noisy half-plane.
         /// </summary>
         private static bool TryHull(
             (double Start, double Width) a,
@@ -835,7 +830,7 @@ namespace OpenNest.Geometry
                 width = fromB;
             }
 
-            return width <= System.Math.PI + TangentSlack;
+            return width <= System.Math.PI + AngleTolerance;
         }
     }
 }

OpenNest.Core/Geometry/SlideEvents.cs

@@ -228,10 +228,7 @@ namespace OpenNest.Geometry
             double lineDy,
             double rayX,
             double rayY,
-            bool arcMoves,
+            bool arcMoves
-            SlideBand.Axis band,
-            SlideBandIndex lineIndex,
-            List<int> candidates
         )
             where TSink : struct, ISlideEventSink
         {
@@ -244,19 +241,8 @@ namespace OpenNest.Geometry
                 var cx = localCx + arcDx;
                 var cy = localCy + arcDy;
 
-                // With an index, visit only the lines CircleMayReachLine can accept, ascending.
+                for (var j = 0; j < lineEntities.Count; j++)
-                var indexed = false;
-                if (lineIndex != null)
                 {
-                    var c = SlideBand.Perp(band, cx, cy);
-                    var radius = System.Math.Abs(r);
-                    indexed = lineIndex.TryRange(c - radius, c + radius, candidates);
-                }
-
-                var count = indexed ? candidates.Count : lineEntities.Count;
-                for (var n = 0; n < count; n++)
-                {
-                    var j = indexed ? candidates[n] : n;
                     if (lineEntities[j] is not Line line)
                         continue;
 
@@ -264,13 +250,6 @@ namespace OpenNest.Geometry
                     var p1y = line.pt1.Y + lineDy;
                     var p2x = line.pt2.X + lineDx;
                     var p2y = line.pt2.Y + lineDy;
-
-                    if (
-                        band != SlideBand.Axis.None
-                        && !SlideBand.CircleMayReachLine(band, cx, cy, r, p1x, p1y, p2x, p2y)
-                    )
-                        continue;
-
                     var ex = p2x - p1x;
                     var ey = p2y - p1y;
 
@@ -497,59 +476,14 @@ namespace OpenNest.Geometry
         public void Enumerate<TSink>(ref TSink sink)
             where TSink : struct, ISlideEventSink
         {
-            // An axis-aligned push only meets entities whose perpendicular extent can hold the
-            // ray. The band tests skip only pairs whose kernels cannot emit and keep the
-            // surviving pairs in their original order, so the emitted events are unchanged.
-            // For larger boundaries, bucket indexes over those extents limit each query to a
-            // superset of the accepted entities, still visited in ascending order.
-            var band = SlideBand.For(dirX, dirY);
-            var indexes = band == SlideBand.Axis.None
-                ? null
-                : SlideBandIndexes.Build(
-                    band,
-                    moving,
-                    movingVertices,
-                    movingDx,
-                    movingDy,
-                    stationary,
-                    stationaryVertices,
-                    arcToLine
-                );
-
             // Phase 1: moving vertices along the push against stationary entities.
             for (var v = 0; v < movingVertices.Length; v++)
             {
                 var vx = movingVertices[v].X + movingDx;
                 var vy = movingVertices[v].Y + movingDy;
 
-                if (
-                    indexes?.Stationary != null
-                    && indexes.Stationary.TryPoint(
-                        SlideBand.Perp(band, vx, vy),
-                        out var first,
-                        out var last
-                    )
-                )
-                {
-                    for (var k = first; k < last; k++)
-                    {
-                        var j = indexes.Stationary.Item(k);
-                        if (!SlideBand.RayMayHit(band, vx, vy, stationary[j], 0, 0))
-                            continue;
-                        SlideEvents.Ray(ref sink, vx, vy, stationary[j], 0, 0, dirX, dirY, true);
-                        if (sink.IsDone)
-                            return;
-                    }
-                    continue;
-                }
-
                 for (var j = 0; j < stationary.Count; j++)
                 {
-                    if (
-                        band != SlideBand.Axis.None
-                        && !SlideBand.RayMayHit(band, vx, vy, stationary[j], 0, 0)
-                    )
-                        continue;
                     SlideEvents.Ray(ref sink, vx, vy, stationary[j], 0, 0, dirX, dirY, true);
                     if (sink.IsDone)
                         return;
@@ -562,44 +496,8 @@ namespace OpenNest.Geometry
                 var vx = stationaryVertices[v].X;
                 var vy = stationaryVertices[v].Y;
 
-                if (
-                    indexes?.Moving != null
-                    && indexes.Moving.TryPoint(
-                        SlideBand.Perp(band, vx, vy),
-                        out var first,
-                        out var last
-                    )
-                )
-                {
-                    for (var k = first; k < last; k++)
-                    {
-                        var j = indexes.Moving.Item(k);
-                        if (!SlideBand.RayMayHit(band, vx, vy, moving[j], movingDx, movingDy))
-                            continue;
-                        SlideEvents.Ray(
-                            ref sink,
-                            vx,
-                            vy,
-                            moving[j],
-                            movingDx,
-                            movingDy,
-                            -dirX,
-                            -dirY,
-                            false
-                        );
-                        if (sink.IsDone)
-                            return;
-                    }
-                    continue;
-                }
-
                 for (var j = 0; j < moving.Count; j++)
                 {
-                    if (
-                        band != SlideBand.Axis.None
-                        && !SlideBand.RayMayHit(band, vx, vy, moving[j], movingDx, movingDy)
-                    )
-                        continue;
                     SlideEvents.Ray(
                         ref sink,
                         vx,
@@ -629,10 +527,7 @@ namespace OpenNest.Geometry
                     0,
                     dirX,
                     dirY,
-                    true,
+                    true
-                    band,
-                    indexes?.StationaryLines,
-                    indexes?.Candidates
                 );
                 if (sink.IsDone)
                     return;
@@ -646,10 +541,7 @@ namespace OpenNest.Geometry
                     movingDy,
                     -dirX,
                     -dirY,
-                    false,
+                    false
-                    band,
-                    indexes?.MovingLines,
-                    indexes?.Candidates
                 );
                 if (sink.IsDone)
                     return;
@@ -661,39 +553,11 @@ namespace OpenNest.Geometry
                 if (!SlideEvents.TryGetCurve(moving[i], out var mcx, out var mcy, out var mr))
                     continue;
 
-                var indexed = false;
+                for (var j = 0; j < stationary.Count; j++)
-                if (indexes?.StationaryCurves != null)
                 {
-                    var c = SlideBand.Perp(band, mcx + movingDx, mcy + movingDy);
-                    var reach = SlideBandIndex.CurveReach(mr);
-                    indexed = indexes.StationaryCurves.TryRange(
-                        c - reach,
-                        c + reach,
-                        indexes.Candidates
-                    );
-                }
-
-                var count = indexed ? indexes.Candidates.Count : stationary.Count;
-                for (var n = 0; n < count; n++)
-                {
-                    var j = indexed ? indexes.Candidates[n] : n;
                     if (!SlideEvents.TryGetCurve(stationary[j], out var scx, out var scy, out var sr))
                         continue;
 
-                    if (
-                        band != SlideBand.Axis.None
-                        && !SlideBand.CirclesMayTouch(
-                            band,
-                            mcx + movingDx,
-                            mcy + movingDy,
-                            mr,
-                            scx,
-                            scy,
-                            sr
-                        )
-                    )
-                        continue;
-
                     SlideEvents.CurveTangency(
                         ref sink,
                         mcx + movingDx,