feat(desktop): add File -> Export Nest Report command

Capture the report target and reject whole-job nesting, open progress
windows, interactive fill and busy plate actions across every view
sharing the nest; revalidate after the save dialog, capture the snapshot
synchronously on the UI thread and render it through OpenNest.Reporting.
Windows adapter tests cover enablement, guards, cancel, success and a
write failure against an existing destination (compile-only on Linux;
Windows runtime acceptance still owed).

.github/workflows/windows-release.yml

@@ -49,7 +49,7 @@ jobs:
           if ($LASTEXITCODE -ne 0) { throw 'Solution build failed.' }
       - name: Run all test projects on Windows
         run: |
-          foreach ($project in @('OpenNest.Tests', 'OpenNest.Engine.Tests', 'OpenNest.IO.Tests', 'OpenNest.WinForms.Tests')) {
+          foreach ($project in @('OpenNest.Tests', 'OpenNest.Engine.Tests', 'OpenNest.IO.Tests', 'OpenNest.WinForms.Tests', 'OpenNest.FrontEnd.Tests')) {
             dotnet test "$project/$project.csproj" -c Release --no-build --logger "trx;LogFileName=$project.trx" --results-directory TestResults
             if ($LASTEXITCODE -ne 0) { throw "$project failed." }
           }

.gitignore

@@ -207,13 +207,21 @@ FakesAssemblies/
 *.db
 *.db-journal
 
-# Claude Code
+# Local agent state and temporary planning/progress documents
 .claude/
+/.hermes/plans/
+/.hermes/progress/
 .superpowers/
 docs/superpowers/
+/docs/*-plan.md
+/docs/*-progress.md
 
 # Launch settings
 **/Properties/launchSettings.json
 
 # Local test config (contains user-specific paths to proprietary test assets)
 OpenNest.Tests/test-config.json
+
+# Vendor programming manuals: keep reference copies outside source control.
+CINCINNATI LASER PROGRAMMING MANUAL.pdf
+TF5200_programming_manual_en.pdf

AGENTS.md

@@ -1,157 +1,62 @@
-# AGENTS.md
+# OpenNest agent instructions
 
-This file contains shared repository instructions for coding agents working on OpenNest. It is the single source of truth; `CLAUDE.md` imports it for Claude Code compatibility.
+Shared instructions; keep `CLAUDE.md` as the thin `@AGENTS.md` import.
+OpenNest is a .NET 8 Windows CNC-nesting application with cross-platform libraries.
 
-## Project Overview
+## Working rules
 
-OpenNest is a Windows desktop application for CNC nesting — arranging 2D parts on material plates to minimize waste. It imports DXF drawings, places parts onto plates using NFP-based (No Fit Polygon) and rectangle-packing algorithms, and can export nest layouts as DXF or post-process them to G-code for CNC cutting machines.
+- Prefer Roslyn Bridge MCP for symbols, references and diagnostics when available; fall back to text search.
+- Use `var` for locals and namespaces matching project directories. Follow `.editorconfig`; format only changed C# files with `dotnet format OpenNest.sln --include <paths>`, then repeat with `--verify-no-changes`. On Linux, prefix both commands with `EnableWindowsTargeting=true`.
+- Keep instructions concise: commands, boundaries and non-obvious safeguards, not class inventories or session history. Update affected instructions and user-facing docs with behavior/build changes; put detailed contracts in `docs/`.
+- Never commit design specs, implementation plans, progress notes or temporary benchmark reports. Keep working records under local, ignored `.hermes/plans/` or `.hermes/progress/`; retain reusable verification procedures in `docs/`.
+- Keep vendor manuals/full-text extracts out of source control unless redistribution is authorized. Write project-specific behavior summaries with citations, separating controller rules, machine macros and unconfirmed behavior.
 
-## Build
+## Build and test
 
-This is a .NET 8 solution using SDK-style `.csproj` files. The desktop app and Windows-dependent projects target `net8.0-windows`; the core libraries and `OpenNest.Console` target `net8.0`. Build the full solution on Windows with:
+```sh
-
+# Full solution: Windows
-```bash
 dotnet build OpenNest.sln
+
+# Cross-platform suites: run independently on Linux/macOS/Windows
+dotnet test OpenNest.Tests/OpenNest.Tests.csproj
+dotnet test OpenNest.Engine.Tests/OpenNest.Engine.Tests.csproj
+dotnet test OpenNest.IO.Tests/OpenNest.IO.Tests.csproj
+
+# Windows runtime tests
+dotnet test OpenNest.WinForms.Tests/OpenNest.WinForms.Tests.csproj
 ```
 
-Cross-platform whole-job engine tests (net8.0, runs on Linux/macOS/Windows without the desktop project or DXF fixtures): `dotnet test OpenNest.Engine.Tests/OpenNest.Engine.Tests.csproj`. The main `OpenNest.Tests` suite also targets `net8.0`: run `dotnet test OpenNest.Tests/OpenNest.Tests.csproj` independently on Linux/macOS/Windows. It must not reference the WinForms `OpenNest` project. The API, Data, and post-processor libraries target `net8.0`. Post-processor projects live under `Posts/` (`Posts/OpenNest.Posts.<Name>/`, referencing `..\..\OpenNest.Core`); their build deployment still targets the desktop app's `net8.0-windows/Posts` directory. Optional CHR-font fixtures are configured through `OpenNest.Tests/test-config.json` and skip when absent.
+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`.
 
-`OpenNest.WinForms.Tests` contains the desktop-assembly-dependent `CadBendNoteTests` (`CadText`) and `CuttingParametersSerializerTests` (`CuttingParametersSerializer`). It targets `net8.0-windows`, references `OpenNest`, and requires a Windows runner: `dotnet test OpenNest.WinForms.Tests/OpenNest.WinForms.Tests.csproj`. Keep future desktop-dependent tests here rather than in `OpenNest.Tests`. Linux cross-compilation uses `dotnet build OpenNest.WinForms.Tests/OpenNest.WinForms.Tests.csproj -p:EnableWindowsTargeting=true`; cross-compilation is not Windows runtime verification.
+Releases: follow [the release procedure](docs/releasing.md) and `scripts/Publish-Windows.ps1`; workflow artifacts are candidates, not published releases. Gitea is authoritative for Git refs.
 
-Cross-platform CAD import tests: `dotnet test OpenNest.IO.Tests/OpenNest.IO.Tests.csproj`. These synthetic-DXF and bend-repair tests target `net8.0`, require no external fixtures, and are included in the solution. Build the headless console independently with `dotnet build OpenNest.Console/OpenNest.Console.csproj`.
+## Project map and boundaries
 
-NuGet dependencies: `ACadSharp` 3.1.32 (DXF/DWG import/export, in OpenNest.IO), `Clipper2` 2.0.0 (region offsetting, in OpenNest.Core), `System.Drawing.Common` 8.0.10, `ModelContextProtocol` + `Microsoft.Extensions.Hosting` (in OpenNest.Mcp), `Microsoft.ML.OnnxRuntime` (in OpenNest.Engine for ML angle prediction), `Microsoft.EntityFrameworkCore.Sqlite` (in OpenNest.Training).
+- `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.
+- Engine plug-ins implement `INestingEngine` with a public parameterless constructor, reference Engine and load from `Engines/` beside the host. Build them outside this repository/solution; do not add their projects here.
+- `OpenNest.IO`: ACadSharp import/export and ZIP-based `.nest` persistence. 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`. Posts live in `Posts/OpenNest.Posts.<Name>/` and deploy to the desktop output's `Posts/` directory.
+- `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.
 
-### Windows release packaging
+## Geometry and ownership safeguards
 
-The GitHub `Windows release build` workflow runs on `release/vX.Y.Z` branches, `vX.Y.Z` tags, or manual dispatch. It builds with .NET 8 on `windows-2022`, runs all four test projects in Release plus the main Debug suite, and executes `scripts/Publish-Windows.ps1`. The script creates a self-contained win-x64 desktop ZIP with all three shipped posts plus pinned Gpt6Astra/Opus55/Qwen38FlashNext plug-ins from `scripts/external-engines.json`, runs their tests against this host, validates package contents/version and registry discovery (including a missing-DLL failure case), launches the extracted app, and writes a SHA-256 checksum. It refuses an existing output directory. Workflow artifacts are release candidates, not automatically published releases; follow [the release procedure](docs/releasing.md). Keep Gitea authoritative for Git refs.
+- Marks are not material: use `SpecialLayers.IsMaterial` when deriving nesting/collision geometry; exclude rapid and scribe moves without removing them from display, cutting time or posts.
+- Clipper is for cached CPU region preparation, never per-pair hot loops. Preserve the hand-written `Collision` kernel's GPU-port contract. Polygon consumers use `ClipperBridge`; directional-distance consumers retain native-arc offsets. Validation uses `OffsetForValidation` and `NestTolerances.SpacingSlack`, not conservative display/preparation padding. Do not loosen tolerances to hide failures.
+- `FillLinear` geometry caches are per public call, keyed by `Program` reference identity; never share them across calls/threads. `PartOverlapChecker` is per check; parts/programs must not mutate during its lifetime.
+- `FillScore` ranks count, utilization, compactness; exact ties keep the current layout. Custom comparers remain authoritative. Preserve extents' negative/nonfinite-input fallback, pair preparation and adjusted-column overlap checks. Do not remove bounds recomputations without threshold/rounding characterization.
+- `ObservableList` events own drawing/plate quantity tracking; avoid double accounting. Cutoff parts are excluded from quantity, utilization and overlap checks.
+- 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.
+- 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.
 
-### Fill performance verification
+Read the relevant contract before changing its behavior:
 
-See [fill verification](docs/performance/fill-verification.md) for opt-in measurements, targeted tests, Debug counter isolation, and predictor initialization rules. Keep training bitmaps by default; the angle builder checks predictor availability before scalar-only extraction.
+- [Nest file format](docs/nest-file-format.md)
-
+- [Directional slides](docs/geometry/directional-slides.md) and [pair-spacing limits](docs/geometry/pair-spacing.md)
-## Architecture
+- [Lead-in placement](docs/geometry/lead-in-placement.md)
-
+- [Material-overlap diagnostics](docs/geometry/visual-overlap-check.md)
-Nine projects form a layered architecture:
+- [Automatic cutoffs and sequencing](docs/automatic-scrap-cutoffs.md)
-
+- [Pre-post verification](docs/post-verification.md)
-### OpenNest.Core (class library)
+- [Cincinnati CL](docs/cincinnati-post-output.md) and [CI Fiber](docs/cincinnati-ci-fiber-post-output.md)
-Domain model, geometry, and CNC primitives organized into namespaces:
+- [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.
-
-- **Root** (`namespace OpenNest`): Domain model — `Nest` → `Plate[]` → `Part[]` → `Drawing` → `Program`. A `Nest` is the top-level container. Each `Plate` has a size, material, quadrant, spacing, and contains placed `Part` instances. Each `Part` references a `Drawing` (the template) and has its own location/rotation. A `Drawing` wraps a CNC `Program`. Also contains utilities: `PartGeometry`, `Align`, `Sequence`, `Timing`.
-- **CNC** (`CNC/`, `namespace OpenNest.CNC`): `Program` holds a list of `ICode` instructions (G-code-like: `RapidMove`, `LinearMove`, `ArcMove`, `SubProgramCall`) and an optional `Variables` dictionary of `VariableDefinition` entries. Programs support absolute/incremental mode conversion, rotation, offset, bounding box calculation, and cloning. `VariableDefinition` stores a named variable's expression, resolved value, and flags (`Inline`, `Global`). `ProgramVariableManager` manages numbered machine variables for post-processor output.
-- **Geometry** (`Geometry/`, `namespace OpenNest.Geometry`): Spatial primitives (`Vector`, `Box`, `Size`, `Spacing`, `BoundingBox`, `IBoundable`) and higher-level shapes (`Line`, `Arc`, `Circle`, `Polygon`, `Shape`) used for intersection detection, area calculation, and DXF conversion. Also contains `Intersect` (intersection algorithms), `ShapeBuilder` (entity chaining), `GeometryOptimizer` (line/arc merging), `SpatialQuery` (directional distance, ray casting, box queries), `ShapeProfile` (perimeter/area analysis), `NoFitPolygon` (convex NFP only), `ConvexHull`, `ConvexDecomposition`, `RotatingCalipers`, `ClipperBridge` (Clipper2 region offsetting for CPU preparation only; see Key Patterns), and `Collision` (overlap detection with Sutherland-Hodgman polygon clipping and hole subtraction; deliberately hand-rolled as the reference for a future GPU kernel, with the port contract in its class summary).
-- **Converters** (`Converters/`, `namespace OpenNest.Converters`): Bridges between CNC and Geometry — `ConvertProgram` (CNC→Geometry), `ConvertGeometry` (Geometry→CNC), `ConvertMode` (absolute↔incremental).
-- **Math** (`Math/`, `namespace OpenNest.Math`): `Angle` (radian/degree conversion), `Tolerance` (floating-point comparison), `Trigonometry`, `Generic` (swap utility), `EvenOdd`, `Rounding` (factor-based rounding), `ExpressionEvaluator` (arithmetic expression parser for G-code variable expressions with `$name` references). Note: `OpenNest.Math` shadows `System.Math` — use `System.Math` fully qualified where both are needed.
-- **CNC/CuttingStrategy** (`CNC/CuttingStrategy/`, `namespace OpenNest.CNC`): `ContourCuttingStrategy` orchestrates cut ordering, lead-ins/lead-outs, and tabs. Includes `LeadIn`/`LeadOut` hierarchies (line, arc, clean-hole variants), `Tab` hierarchy (normal, machine, breaker), and `CuttingParameters`/`AssignmentParameters`/`SequenceParameters` configuration.
-- **Collections** (`Collections/`, `namespace OpenNest.Collections`): `ObservableList<T>`, `DrawingCollection`.
-- **CutOffs** (`namespace OpenNest`): `CutOff` (axis-aligned cut line with position, axis, optional start/end limits), `CutOffAxis` enum (`Horizontal`, `Vertical`), `CutOffSettings` (clearance, overtravel, min segment length, direction), `CutDirection` enum (`TowardOrigin`, `AwayFromOrigin`). Cut-offs generate CNC `Program` objects with trimmed line segments that avoid parts.
-- **Splitting** (`Splitting/`, `namespace OpenNest`): `DrawingSplitter` splits a Drawing into multiple pieces along split lines. `ISplitFeature` strategy pattern with implementations: `StraightSplit` (clean edge), `WeldGapTabSplit` (rectangular tab spacers on one side), `SpikeGrooveSplit` (interlocking spike/V-groove pairs). `AutoSplitCalculator` computes split lines for fit-to-plate and split-by-count modes. Supporting types: `SplitLine`, `SplitParameters`, `SplitFeatureResult`.
-- **Quadrant system**: Plates use quadrants 1-4 (like Cartesian quadrants) to determine coordinate origin placement. This affects bounding box calculation, rotation, and part positioning.
-
-### OpenNest.Engine (class library, depends on Core)
-Nesting algorithms use the jobs-only API. `INestingEngine.Solve(NestJob)` returns `NestJobResult`; `NestJobRunner` alone commits demand and finite/unlimited stock accounting; `IPlateNester` only proposes a one-sheet candidate; and `PlateNesterFactory` resolves a named built-in placement strategy.
-
-- **Whole-job API (`Jobs/`)**: `NestJob` owns part requirements, physical stock, and options for one material/thickness/unit system. `PartGeometrySnapshot` contains owned flat rapid/line/arc geometry; results contain stock IDs and placement poses (radians), not mutable desktop models. `NestJobPlacementValidator` validates contours, rotation, usable work area, overlap, and spacing before accounting commits. The runner selects valid trial candidates greedily by priority vector, sheet area, envelope, and input order; an incomplete result reports why but does not prove geometric impossibility. `DrawingJobMapper` and `NestResultMaterializer` are the domain-boundary adapters.
-- **Placement boundary (`Jobs/Placement/`, `Jobs/Adapters/`)**: `DefaultPlateNester`, `StripPlateNester`, and `RemnantPlateNester` are built-ins with run-scoped private geometry. `PlateFillService` is the public single-plate proposal service for interactive fill/group/pack flows; it returns parts without mutating caller-owned plates. Job-path identity is reference-based rather than drawing name; `PlateOptimizer` retains name-based helpers and remains outside the runner path.
-- **Filler pipeline (`Jobs/Placement/Fillers/`)**: internal `DefaultPlateFiller`, `StripPlateFiller`, and policy-backed `RemnantPlateFiller` implement the standard single-plate geometry pipeline. `Default` runs the Linear, Pairs, RectBestFit, and Extents phases; remnant variants preserve their distinct comparer, direction, trim-axis, and angle-ordering policies.
-- **Engine registration**: `NestingEngineRegistry` holds whole-job `INestingEngine` implementations including the four fixed strategies and `StockLadder`. It loads plug-ins that implement `INestingEngine` and have a public parameterless constructor. Plug-ins for the removed single-plate inheritance API are not binary compatible.
-- **Plugin engines**: independent `INestingEngine` plugins are class libraries that reference `OpenNest.Engine` and are built outside `OpenNest.sln`. The desktop app and `OpenNest.Benchmark` load them from an `Engines/` folder next to their build output (e.g. `OpenNest.Benchmark/bin/<Config>/net8.0/Engines/`). Do not add engine projects to this repo.
-- **IFillComparer**: Interface enabling filler-specific scoring. `DefaultFillComparer` (count-then-density), `VerticalRemnantComparer` (minimize X-extent), and `HorizontalRemnantComparer` (minimize Y-extent) are grouped into `FillPolicy` on `FillContext`.
-- **Fill/** (`namespace OpenNest.Engine.Fill`): Fill algorithms — `FillLinear` (grid-based), `FillExtents` (extents-based pair tiling), `PairFiller` (interlocking pairs), `ShrinkFiller`, `RemnantFiller`/`RemnantFinder`, `Compactor` (post-fill gravity compaction), `FillScore` (lexicographic comparison: count > utilization > compactness), `Pattern`/`PatternTiler`, `PartBoundary`, `RotationAnalysis`, `AngleCandidateBuilder`, `BestCombination`, `AccumulatingProgress`.
-- **Strategies/** (`namespace OpenNest.Engine.Strategies`): Pluggable fill strategy layer — `IFillStrategy` interface, `FillContext`, `FillStrategyRegistry` (auto-discovers strategies via reflection, supports plugin DLLs), `FillHelpers`. Built-in strategies: `LinearFillStrategy`, `PairsFillStrategy`, `RectBestFitStrategy`, `ExtentsFillStrategy`.
-- **BestFit/** (`namespace OpenNest.Engine.BestFit`): NFP-based pair evaluation pipeline — `BestFitFinder` orchestrates angle sweeps, `PairEvaluator`/`IPairEvaluator` scores part pairs, `RotationSlideStrategy`/`ISlideComputer` computes slide distances. `BestFitCache` and `BestFitFilter` optimize repeated lookups.
-- **RectanglePacking/** (`namespace OpenNest.Engine.RectanglePacking`): `FillBestFit` (single-item fill, tries horizontal and vertical orientations), `PackBottomLeft` (multi-item bin packing, sorts by area descending). Both operate on `Bin`/`Item` abstractions.
-- **CirclePacking/** (`namespace OpenNest.Engine.CirclePacking`): Alternative packing for circular parts.
-- **ML/** (`namespace OpenNest.Engine.ML`): `AnglePredictor` (ONNX model for predicting good rotation angles), `FeatureExtractor` (part geometry features; `Extract(drawing, includeBitmask: false)` skips the 32x32 training bitmap for inference while scalars stay identical; the default overload keeps it for training), `BruteForceRunner` (full angle sweep for training data).
-- `NestItem`: Input to the engine — wraps a `Drawing` with quantity, priority, and rotation constraints.
-- `NestProgress`: Progress reporting model with `NestPhase` enum for UI feedback.
-
-### OpenNest.IO (class library, depends on Core)
-File I/O and format conversion. Uses ACadSharp for DXF/DWG support.
-
-- `DxfImporter`/`DxfExporter` — DXF file import/export via ACadSharp.
-- `NestReader`/`NestWriter` — custom ZIP-based nest format (JSON metadata + G-code programs, v2 format).
-- `ProgramReader` — G-code text parser.
-- `Extensions` — conversion helpers between ACadSharp and OpenNest geometry types.
-- `CadImporter` — shared "DXF → Drawing" service used by the UI, console, MCP, API, and training projects. Two-stage API: `Import(path, options)` loads raw entities, runs bend detection, and returns a mutable `CadImportResult`; `BuildDrawing(result, visible, bends, quantity, customer, editedProgram)` produces a fully-populated `Drawing` with `Source.Offset`, `SourceEntities`, `SuppressedEntityIds`, and bends. `ImportDrawing(path, options)` composes both stages for headless callers.
-- `CadImportOptions`, `CadImportResult` — inputs and intermediate state for `CadImporter`.
-- `Bending/BendRepair` — conservative opt-in repair configured by `CadImportOptions.BendRepair`. Requires explicit inches/mm source units and an endpoint movement limit above 0.001 and at most 3.175 physical mm. Only unambiguous paired ETCH/SCRIBE ticks may move along the existing bend axis; cut geometry and unrelated marks must remain unchanged. Opt-in imports preserve source marks without blanket etch regeneration and expose per-bend outcomes in `CadImportResult.BendRepairReports`.
-
-### OpenNest.Console (console app, depends on Core + Engine + IO)
-Command-line interface for batch nesting (`net8.0`). Supports DXF import, plate configuration, linear fill, and multi-drawing auto-nesting through the active engine's `Nest()` (`--autonest`). `--repair-bends-mm <limit> --cad-units inches|mm` opts newly imported DXFs into conservative bend repair and prints per-bend reports; it does not rescale coordinates or repair saved nests.
-
-### OpenNest.Gpu (class library, depends on Core + Engine)
-GPU-accelerated pair evaluation for best-fit nesting. `GpuPairEvaluator` implements `IPairEvaluator`, `GpuSlideComputer` implements `ISlideComputer`, and `PartBitmap` handles rasterization. `GpuEvaluatorFactory` provides factory methods.
-
-### OpenNest.Training (console app, depends on Core + Engine)
-Training data collection for ML angle prediction. `TrainingDatabase` stores per-angle nesting results in SQLite via EF Core for offline model training.
-
-### OpenNest.Benchmark (console app, depends on Core + Engine + IO)
-Compares registered `INestingEngine` implementations against each other on real `.nest` files. Each engine solves the whole job — it owns its own multi-plate/size strategy rather than being handed one already-sized plate at a time. Fully generic — it never hardcodes drawing geometry, just reads whatever drawings/quantities/plate settings each input file already has.
-
-- `JobLoader` builds `BenchmarkJob`s from a `.nest` file or a folder of them via `NestReader`, using every drawing with `Quantity.Required > 0`. `--sheet-sizes` can sweep a fixed list of plate sizes instead of each file's own.
-- `DxfManifestLoader` builds a `BenchmarkJob` from a JSON manifest (`sheetSizes`, `spacing`, `edgeSpacing`, `quadrant`, `parts[] { dxf, quantity, allowRotation }`) instead of a `.nest`, importing each DXF with `CadImporter.ImportDrawing`. DXF paths resolve relative to the manifest; sheet sizes are required (manifest or `--sheet-sizes`, which overrides). `allowRotation: false` locks rotation the same way `NestRunner` does. `JobLoader.Load` routes `*.json` inputs to it, and folder scans pick up `*.nest` plus `*.manifest.json` (plain `*.json` is ignored so `--output` reports are never read as manifests). Invalid manifests throw rather than being skipped.
-- `BenchmarkJob.BuildNestJob(maxPlates)` converts the job into a `NestJob`: one `NestJobPart` per requested drawing (via `DrawingJobMapper.FromDrawing`) and one `NestPlateStock` per candidate sheet size (unlimited quantity — the engine decides how many of each size it uses).
-- `BenchmarkRunner` fans the (job × engine) pairs out with `Parallel.ForEach` (`NoBuffering`, `MaxDegreeOfParallelism` from `--parallel`, CLI default 3, `Run`'s own default 1) and writes results by index so report order stays job-then-engine. Each solve builds its own `NestJob` snapshot and materialized drawings, so solves share no mutable drawing state. Concurrent solves compete for cores, so `Time(ms)` is only clean at `--parallel 1`. It calls each engine's `INestingEngine.Solve(NestJob)` once per job, under a wall-clock timeout so a runaway or hanging engine can't stall the whole benchmark run, then materializes the result back into legacy `Plate`/`Part` objects via `NestResultMaterializer` for scoring.
-- `NestValidator` checks the returned layout: every part inside `Plate.WorkArea()`, every pair at least `Plate.PartSpacing` apart (checked geometrically: each part's perimeter inflated and cutouts shrunk by the spacing, tested against the other part's raw material with holes subtracted, so part-in-part inside a cutout is legal; an X-sorted bounding-box sweep prunes distant pairs), and no drawing over its requested quantity. `ValidateAgainstJob` also checks the raw `NestJobResult`: every sheet must match a stock entry the job offered (size, spacing, edge spacing, quadrant; finite quantity not overdrawn), and every placement rotation must satisfy its part's `RotationPolicy.Allows`. An invalid, throwing, or timed-out run places nothing for scoring.
-- Ranking (`Report.Compare`): valid > invalid, fully placed > not, then lower `JobResult.Cost`, then fewer plates. Cost = salvage-credited sheet area (`StockLadderNestingEngine.EstimateNetArea` per plate, recomputed from job geometry) + `BenchmarkJob.UnplacedPartPenalty` (largest candidate sheet area) per unplaced part, so dropping hard parts never improves the score. The summary sums cost and areas across jobs (area-weighted, not a mean of per-job percentages). Without `--sheet-sizes`, `.nest` jobs only offer their original sizes, and the CLI warns that this hints engines. Numeric CLI and manifest sheet sizes parse with the invariant culture (`JobLoader.TryParseSheetSize`).
-- `--engines Name1,Name2` filters to specific registered engines (default: all); `--csv <path>` writes a flat per-job CSV alongside the console report. `--progress` passes each solve a `JobProgressLog`, which writes `[job/engine]` lines for start, finish, every `PlateCommitted`, and `EvaluatingCandidate` throttled to one line per 2 s.
-- `tools/PepNestExport` (outside the solution; references `PepLib.Core` from the sibling `PepApi.Core` repo) converts a PepApi year of PEP nests into `.nest` files that keep PEP's placements as the benchmark `Baseline`. PEP loop quirks: sub-loop calls continue the incremental position; lead-in/out, `DESTRUCT CUT` and non-cut moves must not reach the program as rapids (a program's bounding box counts rapid endpoints); contours may be broken by uncut micro-joint tabs (a rapid of up to 0.25 across the tab, at the seam or mid-contour, e.g. a cutout cut as two halves), which the export bridges only where the pieces chain into a closed loop; and one drawing can be placed through several loops with different origins.
-
-### OpenNest.Mcp (console app, depends on Core + Engine + IO)
-MCP server for Claude Code integration. Exposes nesting operations as MCP tools over stdio transport. Published to `~/.claude/mcp/OpenNest.Mcp/`.
-
-- **Tools/InputTools**: `load_nest`, `import_dxf`, `create_drawing` (built-in shapes or G-code).
-- **Tools/SetupTools**: `create_plate`, `clear_plate`.
-- **Tools/NestingTools**: `fill_plate`, `fill_area`, `fill_remnants`, `pack_plate`.
-- **Tools/InspectionTools**: `get_plate_info`, `get_parts`, `check_overlaps`.
-- `NestSession` — in-memory state across tool calls (current Nest, standalone plates/drawings).
-
-### OpenNest (WinForms WinExe, depends on Core + Engine + IO)
-The UI application with MDI interface.
-
-- **Auto Nest engine routing**: when the selected engine is not a built-in fill strategy (`EngineSelection.IsFillStrategy` is false, i.e. StockLadder or an `Engines/` plug-in), `MainForm.RunJobEngineAsync` solves the whole job through `INestingEngine.Solve`. `JobEngineNest` builds the `NestJob` from the auto-nest items and either the plate options or the current plate, and it converts `NestJobProgress` for `NestProgressForm`: an engine's `LegacyProgress` passes through, and otherwise the stage and committed counts become the description. It then binds the result poses back onto the nest's own drawings. Whole-job engines throw on cancel, so the progress form hides Accept (`AllowAccept = false`) and Stop discards the run. Built-in strategies keep the existing per-plate fill path.
-- **Forms/**: `MainForm` (MDI parent), `EditNestForm` (MDI child per nest), `SplitDrawingForm` (split oversized drawings into smaller pieces, launched from CadConverterForm), plus dialogs for plate editing, auto-nesting, DXF conversion, cut parameters, etc.
-- **Controls/**: `PlateView` (2D plate renderer with zoom/pan, supports temporary preview parts), `DrawingListBox`, `DrawControl`, `QuadrantSelect`.
-- **Actions/**: User interaction modes — `ActionSelect`, `ActionClone`, `ActionFillArea`, `ActionSelectArea`, `ActionZoomWindow`, `ActionSetSequence`, `ActionCutOff`.
-- **Post-processing**: `IPostProcessor` plugin interface loaded from DLLs in a `Posts/` directory at runtime. Plugin sources live in the repository's `Posts/` folder (the solution's `PostProcessors` folder).
-
-## File Format
-
-Nest files (`.nest`, ZIP-based) use v2 JSON format:
-- `nest.json` — single JSON file containing all nest metadata: nest info (name, units, customer, dates, notes), plate defaults (size, thickness, quadrant, spacing, material, edge spacing), drawings array (id, name, color, quantity, priority, rotation constraints, material, source), and plates array (id, size, material, edge spacing, parts with drawingId/x/y/rotation, cutoffs with x/y/axis/startLimit/endLimit)
-- `programs/program-N` — G-code text for each drawing's cut program (N = drawing id)
-- `bestfits/bestfit-N` — JSON array of best-fit pair evaluation results per drawing, keyed by plate size/spacing (optional, only present if best-fit data was computed)
-
-## Tool Preferences
-
-Always use Roslyn Bridge MCP tools (`mcp__RoslynBridge__*`) as the primary method for exploring and analyzing this codebase. It is faster and more efficient than file-based searches. Use it for finding symbols, references, diagnostics, type hierarchies, and code navigation. Only fall back to Glob/Grep when Roslyn Bridge cannot fulfill the query.
-
-## Code Style
-
-- Always use `var` instead of explicit types (e.g., `var parts = new List<Part>();` not `List<Part> parts = new List<Part>();`).
-
-## Documentation Maintenance
-
-Always keep `README.md` and `AGENTS.md` up to date when making changes that affect project structure, architecture, build instructions, dependencies, or key patterns. If you add a new project, change a namespace, modify the build process, or alter significant behavior, update both files as part of the same change. Keep `CLAUDE.md` as a thin `@AGENTS.md` import rather than duplicating shared instructions.
-
-**Do not commit** design specs, implementation plans, or other temporary planning documents (`docs/superpowers/` etc.) to the repository. These are working documents only — keep them local and untracked.
-
-## Key Patterns
-
-- OpenNest.Core uses multiple namespaces: `OpenNest` (root domain), `OpenNest.CNC`, `OpenNest.Geometry`, `OpenNest.Converters`, `OpenNest.Math`, `OpenNest.Collections`.
-- OpenNest.Engine uses sub-namespaces: `OpenNest.Engine.Fill` (fill algorithms), `OpenNest.Engine.Strategies` (pluggable strategy layer), `OpenNest.Engine.BestFit`, `OpenNest.Engine.Jobs` (whole-job API, with `.Placement` and `.Adapters`), `OpenNest.Engine.ML`, `OpenNest.Engine.RapidPlanning`, `OpenNest.Engine.Sequencing`, `OpenNest.Engine.RectanglePacking`, `OpenNest.Engine.CirclePacking`. All Engine types live in namespaces matching their directory under `OpenNest.Engine/` (project files use `namespace X;` file-scoped or block style); consumers reference them via explicit `using OpenNest.Engine[.Sub];` directives.
-- `ObservableList<T>` provides ItemAdded/ItemRemoved/ItemChanged events used for automatic quantity tracking between plates and drawings.
-- Angles throughout the codebase are in **radians** (use `Angle.ToRadians()`/`Angle.ToDegrees()` for conversion).
-- `Tolerance.Epsilon` is used for floating-point comparisons across geometry operations.
-- Nesting uses async progress/cancellation: `IProgress<NestProgress>` and `CancellationToken` flow through the engine to the UI's `NestProgressForm`.
-- **Spacing offsets**: polygon consumers (`PolygonHelper`, `PartBoundary`, `NestValidator`, `CutOff`, the `LayoutPart` Draw Offset display) use `ClipperBridge.Offset`/`OffsetPerimeter`: one Clipper pass over the flattened region (perimeter positive, cutouts negative) with round joins at 1e-4 precision, so features narrower than twice the spacing collapse and closed-up holes disappear. `circumscribe: true` is the conservative mode (perimeter arcs circumscribed with endpoints kept on the arc, cutout arcs inscribed, inflation padded by the join chord error) and never under-estimates the spacing. `NestValidator` uses `OffsetForValidation` instead: the same flattening with fine joins and no padding, inflated by the spacing less `NestTolerances.SpacingSlack` (0.0005), so a layout exactly at the spacing passes even after rotation and coordinate rounding leave it ~1e-4 short. `NestJobPlacementValidator` applies the same slack to its edge-distance check. `PartGeometry.GetOffsetPerimeterEntities`/`GetOffsetPartEntities` stay on the arc-preserving per-entity `Shape.OffsetOutward`/`OffsetInward` (internal) because directional-distance loops are much faster on native arcs; their chains are closed but may keep zero-area spikes inside the envelope. `FillLinear` prepares each distinct `Program` (reference identity) once per public `Fill`/`FillRow` call and translates clones; never share that cache across calls or threads. Both `HasOverlappingParts` loops use one `PartOverlapChecker` per call (same keying; it also caches each part's triangles; parts and programs must not change while it is in use). Clipper is allowed only for cached CPU preparation, never in per-pair hot loops.
-- **Marks are not material**: scribe/etch moves are marked on the surface, never cut through, so they are left out of nesting. `SpecialLayers.IsMaterial(layer)` (excludes `Rapid` and `Scribe`) is the filter for every consumer that builds part material from a program: drawing area, canonical angle, part collision, `PartGeometry`, plate perimeters, best-fit/pair evaluation, rotation analysis, the GPU evaluators, and both validators (`NestJobPlacementValidator`, benchmark `NestValidator`). Cutting time, on-screen display, splitting, and post-processors still see marks. Older `.nest` files (e.g. `tools/PepNestExport` output) saved etch as cut moves while their source entities kept the `SCRIBE` layer; `NestReader` runs `ScribeLayerRepair` on load to move matching program moves back to `Scribe`.
-- **Native curve contact**: CPU best-fit and shared directional queries use `SpatialQuery.CurveTangencyDistance` for sum- and difference-radius tangency, checking both forward roots and both arc spans. It supplements vertex/line phases, not a complete collision/clearance validator. See [pair-spacing checks](docs/geometry/pair-spacing.md) for the regression and remaining limits.
-- `Compactor` performs post-fill gravity compaction — after filling, parts are pushed toward a plate edge using directional distance calculations to close gaps between irregular shapes.
-- `FillScore` uses lexicographic comparison (count > utilization > compactness) to rank fill results consistently across all fill strategies. After its null/empty guards, `DefaultFillComparer` decides unequal counts without scoring; equal counts still use scores, and exact ties retain the current layout. `FillHelpers.FillPattern` computes eager scores only when no custom comparer is supplied; custom comparers remain authoritative and may perform their own scoring.
-- **Extents column pitch**: for finite valid geometry, finite pair height, and finite nonnegative spacing, `FillExtents.BuildColumn` uses `pair.Bbox.Width + partSpacing` directly. The old vertical slide calculation clamps to the same pitch, so it need not prepare boundaries or temporary test clones. Negative/nonfinite spacing or nonfinite pair height retains the legacy calculation: public/interactive callers do not all validate spacing. Do not remove `BuildPair` boundary preparation or the adjusted-column overlap fallback, or turn this shortcut into a geometry/validation policy change.
-- **Cut-off materialization lifecycle**: `CutOff` objects live on `Plate.CutOffs`. Each generates a `Drawing` (with `IsCutOff = true`) whose `Program` contains trimmed line segments. `Plate.RegenerateCutOffs(settings)` removes old cut-off Parts, recomputes programs, and re-adds them to `Plate.Parts`. Regeneration triggers: cut-off add/remove/move, part drag complete, fill complete, plate transform. Cut-off Parts are excluded from quantity tracking, utilization, overlap detection, and nest file serialization (programs are regenerated from definitions on load).
-- **User-defined G-code variables**: Programs can contain named variable definitions (`name = expression [inline] [global]`) referenced in coordinates with `$name`. Variables resolve to doubles at parse time for geometry/nesting. `VariableRefs` on `Motion`/`Feedrate` track the symbolic link so post processors can emit machine variable references. Cincinnati post maps non-inline variables to numbered machine variables (`#200+`) with descriptive comments. Global variables share a number across programs; local variables get per-drawing numbers. `ProgramReader` uses a two-pass parse (collect definitions, then parse G-code with substitution). `NestWriter` serializes definitions and `$references` back to text for round-trip fidelity.
-- **CAD import pipeline**: All "DXF → Drawing" conversion goes through `OpenNest.IO.CadImporter`. The UI form uses `Import` on file load (storing the mutable result in a `FileListItem`) and `BuildDrawing` on save (passing the user's current visible entities and bends). MCP, API, and Training projects use `ImportDrawing` for headless conversion. The console uses `Import` followed by `BuildDrawing` so it can report bend-repair outcomes. This guarantees all callers produce drawings with the same shape: pierce-point `Source.Offset`, stable `SourceEntities` with GUIDs, `SuppressedEntityIds`, detected bends, and metadata.
-- **GravographIS engrave/cut passes**: The `OpenNest.Posts.GravographIS` post splits geometry by `LayerType` into ordered tool passes — engrave (`Scribe`) then cut (`Cut`/`Leadin`/`Leadout`); `Display` is skipped. `ConvertGeometry` tags DXF layers `ENGRAVE`/`ETCH` and the saved `SCRIBE` layer (lines, arcs, circles) as `Scribe`; the layer round-trips through `.nest` via `NestWriter`/`ProgramReader`. `NestPolylineExtractor.ExtractLayered` carries `LayerType` per polyline (splitting a continuous chain at any layer change); `GravographISPostProcessor.BuildPasses` groups them and `GravographISWriter.Write(IReadOnlyList<GravographPass>, …)` emits each pass at its own feed/depth, parking to origin and emitting an operator pause (motor off → aux off → `LB` console message → motor on) before any pass whose config has `PauseBefore`. Per-pass parameters live in `GravographISPostConfig` (an `IConfigurablePostProcessor` config with `Engrave`/`Cut` `LayerCutConfig` blocks), edited in the shared `PostProcessorConfigForm` PropertyGrid and persisted to JSON. The cut block pauses by default so the operator can swap/adjust the tool (the spring-floated spindle means programmed `DZ` depth is not the real cut depth).

OpenNest.Api/NestRequest.cs

@@ -16,6 +16,9 @@ public class NestRequest
 
     /// <summary>Built-in whole-job placement strategy. Explicit values take precedence over legacy Strategy.</summary>
     public string PlacementStrategy { get; init; } = "Default";
+
+    /// <summary>Registered whole-job engine. Null uses PlacementStrategy (or legacy Strategy).</summary>
+    public string Engine { get; init; }
     public string Material { get; init; } = "Steel, A1011 HR";
     public double Thickness { get; init; } = 0.06;
     public double Spacing { get; init; } = 0.1;

OpenNest.Api/NestResponse.cs

@@ -5,8 +5,8 @@ using System.IO.Compression;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Threading.Tasks;
-using OpenNest.IO;
 using OpenNest.Engine.Jobs;
+using OpenNest.IO;
 
 namespace OpenNest.Api;
 
@@ -19,9 +19,12 @@ public sealed record NestStockUsage(string StockId, int Used, int? Remaining);
 /// <summary>Maps each materialized physical sheet to its source stock identity.</summary>
 public sealed record NestPlateStockMapping(int PlateIndex, string StockId);
 
+/// <summary>Independent geometry validation; null on old archives means not recorded.</summary>
+public enum NestValidationStatus { Valid, Invalid, Unrepresentable }
+
 public class NestResponse
 {
-    public const int CurrentSchemaVersion = 2;
+    public const int CurrentSchemaVersion = 3;
 
     /// <summary>Zero identifies an archive written before response metadata was versioned.</summary>
     public int SchemaVersion { get; init; } = CurrentSchemaVersion;
@@ -35,6 +38,9 @@ public class NestResponse
     /// <summary>Null means an older archive did not record whole-job fulfillment status.</summary>
     public NestJobStatus? Status { get; init; }
     public NestJobStopReason? StopReason { get; init; }
+    /// <summary>Fulfillment status is not geometry acceptance. Review this status before using Nest.</summary>
+    public NestValidationStatus? ValidationStatus { get; init; }
+    public IReadOnlyList<string> Violations { get; init; } = [];
     public IReadOnlyList<NestPartFulfillment> Fulfillment { get; init; } = [];
     public IReadOnlyList<NestStockUsage> StockUsage { get; init; } = [];
     public IReadOnlyList<NestPlateStockMapping> PlateStockMappings { get; init; } = [];
@@ -75,6 +81,8 @@ public class NestResponse
                     ElapsedTicks = Elapsed.Ticks,
                     Status = Status,
                     StopReason = StopReason,
+                    ValidationStatus = ValidationStatus,
+                    Violations = Violations is null ? [] : new List<string>(Violations),
                     Fulfillment = Fulfillment is null
                         ? []
                         : new List<NestPartFulfillment>(Fulfillment),
@@ -158,6 +166,8 @@ public class NestResponse
             Elapsed = TimeSpan.FromTicks(archive.ElapsedTicks),
             Status = hasStatusMetadata ? archive.Status : null,
             StopReason = hasStatusMetadata ? archive.StopReason : null,
+            ValidationStatus = archive.ValidationStatus,
+            Violations = archive.Violations ?? [],
             Fulfillment = hasStatusMetadata ? archive.Fulfillment ?? [] : [],
             StockUsage = hasStatusMetadata ? archive.StockUsage ?? [] : [],
             PlateStockMappings = hasStatusMetadata ? archive.PlateStockMappings ?? [] : [],
@@ -175,6 +185,8 @@ public class NestResponse
         public long ElapsedTicks { get; init; }
         public NestJobStatus? Status { get; init; }
         public NestJobStopReason? StopReason { get; init; }
+        public NestValidationStatus? ValidationStatus { get; init; }
+        public List<string> Violations { get; init; } = [];
         public List<NestPartFulfillment> Fulfillment { get; init; } = [];
         public List<NestStockUsage> StockUsage { get; init; } = [];
         public List<NestPlateStockMapping> PlateStockMappings { get; init; } = [];

OpenNest.Api/NestRunner.cs

@@ -5,10 +5,9 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using OpenNest.IO;
 using OpenNest.Engine;
 using OpenNest.Engine.Jobs;
-using OpenNest.Engine.Jobs.Adapters;
+using OpenNest.IO;
 
 namespace OpenNest.Api;
 
@@ -32,7 +31,7 @@ public static class NestRunner
         var sw = Stopwatch.StartNew();
         var parts = IdentifyParts(requestParts);
         var importedByPath = new Dictionary<string, Drawing>(StringComparer.Ordinal);
-        var jobParts = new List<NestJobPart>(parts.Count);
+        var items = new List<NestItem>(parts.Count);
 
         foreach (var part in parts)
         {
@@ -68,23 +67,64 @@ public static class NestRunner
                 importedByPath.Add(part.Request.DxfPath, drawing);
             }
 
-            ConfigureDrawingForRequirement(drawing, part.Request);
+            // Each requirement keeps its own identity/constraints even when paths are shared.
-            jobParts.Add(DrawingJobMapper.FromDrawing(part.Id, drawing, part.Request.Quantity));
+            var requirementDrawing = new Drawing(part.Id, drawing.Program);
+            ConfigureDrawingForRequirement(requirementDrawing, part.Request);
+            requirementDrawing.Quantity.Required = part.Request.Quantity;
+            items.Add(new NestItem
+            {
+                Drawing = requirementDrawing,
+                Quantity = part.Request.Quantity,
+                Priority = part.Request.Priority,
+                StepAngle = requirementDrawing.Constraints.StepAngle,
+                RotationStart = requirementDrawing.Constraints.StartAngle,
+                RotationEnd = requirementDrawing.Constraints.EndAngle,
+            });
         }
 
-        var job = new NestJob(
+        var stock = CreateStock(request);
-            jobParts,
+        var engineName = request.Engine ?? ResolvePlacementStrategy(request);
-            CreateStock(request),
-            new NestJobOptions(ResolvePlacementStrategy(request))
-        );
         var jobProgress = progress == null ? null : new JobProgressBridge(progress);
-        var result = new NestJobRunner(PlateNesterFactory.Create).Solve(job, jobProgress, token);
+        var result = NestPipeline.Run(new NestPipelineRequest(
+            engineName, items, stock, new NestJobOptions(engineName)), jobProgress, token);
 
-        // This is the sole translation from immutable result poses to mutable legacy output objects.
+        // API returns a detached proposal, not an acceptance/commit to a caller's nest.
-        var materialized = NestResultMaterializer.Materialize(job, result);
+        // Invalid but representable proposals retain every pose and carry explicit validation status.
-        var nest = materialized.Nest;
+        var nest = new Nest { Thickness = request.Thickness, Material = new Material(request.Material) };
-        nest.Thickness = request.Thickness;
+        foreach (var item in items)
-        nest.Material = new Material(request.Material);
+            nest.Drawings.Add(item.Drawing);
+        foreach (var proposed in result.Plates)
+        {
+            var plate = new Plate(proposed.Stock.Size)
+            {
+                PartSpacing = proposed.Stock.PartSpacing,
+                EdgeSpacing = proposed.Stock.EdgeSpacing,
+                Quadrant = proposed.Stock.Quadrant,
+                Quantity = 1,
+            };
+            plate.Parts.AddRange(proposed.Parts);
+            nest.Plates.Add(plate);
+        }
+
+        // Pipeline IDs are internal part-i values. Exposed counts/IDs come from the
+        // returned, bound placements and the original request, never plug-in summaries.
+        var counts = result.Plates.SelectMany(p => p.Parts)
+            .GroupBy(p => p.BaseDrawing).ToDictionary(g => g.Key, g => g.Count());
+        var fulfillment = parts.Select((part, i) =>
+        {
+            var placed = counts.GetValueOrDefault(items[i].Drawing);
+            return new NestPartFulfillment(part.Id, part.Request.Quantity, placed,
+                System.Math.Max(0, part.Request.Quantity - placed));
+        }).ToArray();
+        var usage = stock.Select(s =>
+        {
+            var used = result.Plates.Count(p => p.Stock.Id == s.Id);
+            return new NestStockUsage(s.Id, used, s.Quantity.HasValue ? System.Math.Max(0, s.Quantity.Value - used) : null);
+        }).ToArray();
+        var complete = fulfillment.All(f => f.Placed == f.Requested);
+        var stopReason = complete ? NestJobStopReason.Completed
+            : usage.All(u => u.Remaining == 0) ? NestJobStopReason.StockExhausted
+            : NestJobStopReason.NoPlacementFound;
 
         var timingInfo = Timing.GetTimingInfo(nest);
         var cutTime = Timing.CalculateTime(timingInfo, request.Cutting);
@@ -97,29 +137,15 @@ public static class NestRunner
                 Utilization = CalculateUtilization(nest),
                 CutTime = cutTime,
                 Elapsed = sw.Elapsed,
-                Status = result.Status,
+                Status = complete ? NestJobStatus.Complete : NestJobStatus.Incomplete,
-                StopReason = result.StopReason,
+                StopReason = stopReason,
-                Fulfillment = result
+                ValidationStatus = !result.CanKeep ? NestValidationStatus.Unrepresentable
-                    .Fulfillment.Select(value => new NestPartFulfillment(
+                    : result.IsValid ? NestValidationStatus.Valid : NestValidationStatus.Invalid,
-                        value.PartId,
+                Violations = result.Violations,
-                        value.Requested,
+                Fulfillment = fulfillment,
-                        value.Placed,
+                StockUsage = usage,
-                        value.Unplaced
+                PlateStockMappings = result.Plates.Select((value, index) =>
-                    ))
+                    new NestPlateStockMapping(index, value.Stock.Id)).ToArray(),
-                    .ToArray(),
-                StockUsage = result
-                    .StockUsage.Select(value => new NestStockUsage(
-                        value.StockId,
-                        value.Used,
-                        value.Remaining
-                    ))
-                    .ToArray(),
-                PlateStockMappings = result
-                    .Plates.Select(value => new NestPlateStockMapping(
-                        value.PlateIndex,
-                        value.StockId
-                    ))
-                    .ToArray(),
                 Nest = nest,
                 Request = request,
             }
@@ -140,6 +166,8 @@ public static class NestRunner
                     "Request parts must not contain null entries.",
                     nameof(requestParts)
                 );
+            if (part.Quantity < 0)
+                throw new ArgumentException("Part quantities must be nonnegative.", nameof(requestParts));
             var id = part.Id ?? $"part-{index}";
             if (string.IsNullOrWhiteSpace(id))
                 throw new ArgumentException("Part IDs must not be blank.", nameof(requestParts));

OpenNest.Console/Program.cs

@@ -7,9 +7,9 @@ using System.Linq;
 using System.Reflection;
 using System.Threading;
 using OpenNest;
+using OpenNest.Diagnostics;
 using OpenNest.Engine;
 using OpenNest.Engine.Jobs;
-using OpenNest.Engine.Jobs.Adapters;
 using OpenNest.Engine.Jobs.Placement;
 using OpenNest.Geometry;
 using OpenNest.IO;
@@ -21,6 +21,33 @@ static class NestConsole
 {
     public static int Run(string[] args)
     {
+        using var cancellation = new CancellationTokenSource();
+        ConsoleCancelEventHandler cancel = (_, e) => { e.Cancel = true; cancellation.Cancel(); };
+        Console.CancelKeyPress += cancel;
+        try
+        {
+            return RunCore(args, cancellation.Token);
+        }
+        catch (OperationCanceledException)
+        {
+            Console.Error.WriteLine("Nesting cancelled; nothing saved.");
+            return 2;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+        finally
+        {
+            Console.CancelKeyPress -= cancel;
+        }
+    }
+
+    static int RunCore(string[] args, CancellationToken token)
+    {
+        token.ThrowIfCancellationRequested();
+        NestingEngineRegistry.LoadPlugins(Path.Combine(AppContext.BaseDirectory, "Engines"));
         var options = ParseArgs(args);
 
         if (options == null)
@@ -100,6 +127,12 @@ static class NestConsole
 
         var plate = nest.Plates[options.PlateIndex];
 
+        if (options.AutoNest && options.KeepParts && plate.Parts.Count > 0)
+        {
+            Console.Error.WriteLine("Error: --autonest --keep-parts cannot use an occupied plate. Use plain fill for existing obstacles.");
+            return 2;
+        }
+
         ApplyTemplate(plate, options);
         ApplyOverrides(plate, options);
 
@@ -110,18 +143,21 @@ static class NestConsole
 
         var existingCount = plate.Parts.Count;
 
-        if (!options.KeepParts)
+        if (!options.AutoNest && !options.KeepParts)
             plate.Parts.Clear();
 
         PrintHeader(nest, plate, drawing, existingCount, options);
 
-        var (success, elapsed) = Fill(nest, plate, drawing, options);
+        var (success, elapsed, accepted) = Fill(nest, plate, drawing, options, token);
+        if (!accepted)
+            return 2; // No save or post may run after a rejected proposal.
 
         var overlapCount = CheckOverlaps(plate, options);
 
         PrintResults(success, plate, elapsed);
-        Save(nest, options);
+        token.ThrowIfCancellationRequested();
-        PostProcess(nest, options);
+        if (!SaveAndPost(nest, options))
+            return 1;
 
         return options.CheckOverlaps && overlapCount > 0 ? 1 : 0;
     }
@@ -185,6 +221,9 @@ static class NestConsole
                 case "--template" when i + 1 < args.Length:
                     o.TemplateFile = args[++i];
                     break;
+                case "--allow-invalid":
+                    o.AllowInvalid = true;
+                    break;
                 case "--autonest":
                     o.AutoNest = true;
                     break;
@@ -194,6 +233,9 @@ static class NestConsole
                 case "--post" when i + 1 < args.Length:
                     o.PostName = args[++i];
                     break;
+                case "--acknowledge-post-risks":
+                    o.AcknowledgePostRisks = true;
+                    break;
                 case "--post-output" when i + 1 < args.Length:
                     o.PostOutput = args[++i];
                     break;
@@ -394,6 +436,8 @@ static class NestConsole
         );
         var existingPartsMessage = options.KeepParts
             ? $"Keeping {existingCount} existing parts"
+            : options.AutoNest
+                ? $"Will replace {existingCount} existing parts only after acceptance"
                 : $"Cleared {existingCount} existing parts";
         Console.WriteLine(
             $"""
@@ -404,15 +448,17 @@ static class NestConsole
         );
     }
 
-    static (bool success, long elapsedMs) Fill(
+    static (bool success, long elapsedMs, bool accepted) Fill(
         Nest nest,
         Plate plate,
         Drawing drawing,
-        Options options
+        Options options,
+        CancellationToken token
     )
     {
         var sw = Stopwatch.StartNew();
         bool success;
+        var accepted = true;
 
         if (options.AutoNest)
         {
@@ -433,7 +479,9 @@ static class NestConsole
                 $"AutoNest: {nestItems.Count} drawing(s), {nestItems.Sum(i => i.Quantity)} total parts"
             );
 
-            success = AutoNestJob(plate, nestItems, options.Engine);
+            var outcome = AutoNestJob(plate, nestItems, options.Engine, options.AllowInvalid, token);
+            accepted = outcome.accepted;
+            success = outcome.committed > 0;
         }
         else
         {
@@ -447,8 +495,9 @@ static class NestConsole
                 item,
                 plate.WorkArea(),
                 null,
-                CancellationToken.None
+                token
             );
+            token.ThrowIfCancellationRequested();
 
             if (parts.Count > 0)
                 plate.Parts.AddRange(parts);
@@ -456,52 +505,45 @@ static class NestConsole
         }
 
         sw.Stop();
-        return (success, sw.ElapsedMilliseconds);
+        return (success, sw.ElapsedMilliseconds, accepted);
     }
 
-    /// <summary>
+    static (bool accepted, int committed) AutoNestJob(
-    /// Solves the drawings as one whole job against this single plate using the named jobs
+        Plate plate, List<NestItem> nestItems, string engineName, bool allowInvalid, CancellationToken token)
-    /// engine, then commits the returned placements onto the plate. Placements are mapped back
-    /// onto the caller's original drawings (same pose semantics as NestResultMaterializer), so
-    /// the saved nest keeps its existing drawing identities.
-    /// </summary>
-    static bool AutoNestJob(Plate plate, List<NestItem> nestItems, string engineName)
     {
-        var engine = NestingEngineRegistry.Create(engineName);
+        var result = NestPipeline.Run(new NestPipelineRequest(
+            engineName, nestItems, NestStockBuilder.SinglePlate(plate)), token: token);
+        foreach (var violation in result.Violations)
+            Console.Error.WriteLine($"Violation: {violation}");
 
-        var parts = new List<NestJobPart>(nestItems.Count);
+        if (!result.CanKeep || result.Plates.Count > 1 || (!result.IsValid && !allowInvalid))
-        var drawingsByPartId = new Dictionary<string, Drawing>(StringComparer.Ordinal);
-        for (var i = 0; i < nestItems.Count; i++)
         {
-            var partId = $"part-{i}";
+            Console.Error.WriteLine(result.Plates.Count > 1
-            parts.Add(DrawingJobMapper.FromItem(partId, nestItems[i]));
+                ? "Error: multiple result sheets cannot be merged onto one target, even with --allow-invalid. Nothing saved."
-            drawingsByPartId[partId] = nestItems[i].Drawing;
+                : !result.CanKeep
+                    ? "Error: result cannot be represented faithfully, even with --allow-invalid. Nothing saved."
+                    : "Error: invalid result discarded. Use --allow-invalid to explicitly keep its violations. Nothing saved.");
+            return (false, 0);
         }
 
-        // One physical sheet: this plate, this solve — the runner owns stock accounting.
+        token.ThrowIfCancellationRequested();
-        var stock = DrawingJobMapper.FromPlate("plate-0", plate, 1);
+        var proposed = result.Plates.SingleOrDefault();
-        var job = new NestJob(parts, [stock]);
+        var committed = proposed?.Parts.Count ?? 0;
-
+        if (committed == 0)
-        var result = engine.Solve(job, null, CancellationToken.None);
-
-        var committed = 0;
-        foreach (var plateResult in result.Plates)
         {
-            foreach (var pose in plateResult.Placements)
+            Console.Error.WriteLine("Error: no placements returned. Existing layout and output left unchanged.");
-            {
+            return (false, 0);
-                if (!drawingsByPartId.TryGetValue(pose.PartId, out var drawing))
-                    continue;
-                var part = new Part(drawing);
-                part.Rotate(pose.Rotation);
-                part.Location = new Vector(pose.X, pose.Y);
-                part.UpdateBounds();
-                plate.Parts.Add(part);
-                committed++;
-            }
         }
 
+        plate.Parts.Clear();
+        plate.Size = proposed.Stock.Size;
+        plate.PartSpacing = proposed.Stock.PartSpacing;
+        plate.EdgeSpacing = proposed.Stock.EdgeSpacing;
+        plate.Quadrant = proposed.Stock.Quadrant;
+        plate.Quantity = 1;
+        plate.Parts.AddRange(proposed.Parts);
         Console.WriteLine($"Engine: {engineName} — committed {committed} placements");
-        return committed > 0;
+        return (true, committed);
     }
 
     static string ResolveFillStrategy(string engineName)
@@ -557,18 +599,16 @@ static class NestConsole
         if (options.NoSave)
             return;
 
-        var firstInput = options.InputFiles[0];
+        var outputFile = NestOutputPath(options);
-        var outputFile =
-            options.OutputFile
-            ?? Path.Combine(
-                Path.GetDirectoryName(firstInput),
-                $"{Path.GetFileNameWithoutExtension(firstInput)}-result{NestFormat.FileExtension}"
-            );
 
         new NestWriter(nest).Write(outputFile);
         Console.WriteLine($"Saved: {outputFile}");
     }
 
+    static string NestOutputPath(Options options) => options.OutputFile
+        ?? Path.Combine(Path.GetDirectoryName(options.InputFiles[0]),
+            $"{Path.GetFileNameWithoutExtension(options.InputFiles[0])}-result{NestFormat.FileExtension}");
+
     static string ResolvePostsDir(Options options)
     {
         if (options.PostsDir != null)
@@ -633,10 +673,13 @@ static class NestConsole
             Console.WriteLine($"  {p.Name,-30} {p.Description}");
     }
 
-    static void PostProcess(Nest nest, Options options)
+    static bool SaveAndPost(Nest nest, Options options)
     {
         if (options.PostName == null)
-            return;
+        {
+            Save(nest, options);
+            return true;
+        }
 
         var postsDir = ResolvePostsDir(options);
         var processors = LoadPostProcessors(postsDir);
@@ -655,7 +698,15 @@ static class NestConsole
             else
                 Console.Error.WriteLine($"No post processors found in: {postsDir}");
 
-            return;
+            return false;
+        }
+
+        var verification = PostVerificationAnalyzer.AnalyzeForPost(nest, post);
+        Console.WriteLine(verification.ToDisplayText());
+        if (!verification.CanPost(options.AcknowledgePostRisks))
+        {
+            Console.Error.WriteLine("Posting blocked: review these warnings. To accept the risks, including possible head crashes and machine or material damage, explicitly use --acknowledge-post-risks for this invocation.");
+            return false;
         }
 
         var outputFile = options.PostOutput;
@@ -669,8 +720,22 @@ static class NestConsole
             );
         }
 
+        var outputFiles = post is IMultiFilePostProcessor multiFile
+            ? multiFile.GetOutputFiles(nest, outputFile)
+            : new[] { outputFile };
+
+        if (!options.NoSave && outputFiles.Any(file => string.Equals(
+            Path.GetFullPath(file), Path.GetFullPath(NestOutputPath(options)), StringComparison.OrdinalIgnoreCase)))
+        {
+            Console.Error.WriteLine("Error: nest save and CNC output paths must be different. No output was written.");
+            return false;
+        }
+
+        Save(nest, options);
         post.Post(nest, outputFile);
-        Console.WriteLine($"Post: {post.Name} -> {outputFile}");
+        foreach (var file in outputFiles)
+            Console.WriteLine($"Post: {post.Name} -> {file}");
+        return true;
     }
 
     static void PrintUsage()
@@ -697,7 +762,8 @@ static class NestConsole
               --size <WxL>           Override plate size (e.g. 60x120); required for DXF-only mode
               --output <path>        Output nest file path (default: <input>-result.nest)
               --template <path>      Nest template for plate defaults (thickness, quadrant, material, spacing)
-              --autonest             Whole-job nesting via the jobs engine (--engine) instead of single-plate fill
+              --autonest             Validated whole-job nesting onto one sheet; replaces only after acceptance
+              --allow-invalid        Explicitly keep representable invalid autonest layouts (default: reject, exit 2)
               --engine <name>        With --autonest: jobs engine (default: Default; also StockLadder, Strip, ...).
                                      Without --autonest: fill strategy (Default, Strip, Vertical Remnant, Horizontal Remnant)
               --keep-parts           Don't clear existing parts before filling
@@ -705,6 +771,7 @@ static class NestConsole
               --no-save              Skip saving output file
               --post <name>          Run a post processor after nesting
               --post-output <path>   Output file for post processor (default: <input>.cnc)
+              --acknowledge-post-risks  Explicitly accept displayed verification risks for this invocation
               --posts-dir <path>     Directory containing post processor DLLs (default: Posts/)
               --list-posts           List available post processors and exit
               -h, --help             Show this help
@@ -725,9 +792,11 @@ static class NestConsole
         public bool NoSave;
         public bool KeepParts;
         public bool AutoNest;
+        public bool AllowInvalid;
         public string Engine = "Default";
         public string TemplateFile;
         public string PostName;
+        public bool AcknowledgePostRisks;
         public string PostOutput;
         public string PostsDir;
         public bool ListPosts;

OpenNest.Core/AutomaticCutOffBatch.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest;
+
+/// <summary>
+/// Plans and applies the same automatic-cutoff settings to a stable, ordered set of plates.
+/// Callers must prevent concurrent edits for the duration of either operation.
+/// </summary>
+public static class AutomaticCutOffBatch
+{
+    /// <summary>Detached plans in plate order. Invalid input identifies the one-based plate number.</summary>
+    public static IReadOnlyList<AutomaticCutOffPlan> Create(IReadOnlyList<Plate> plates,
+        AutomaticCutOffOptions options, CutOffSettings settings)
+    {
+        ArgumentNullException.ThrowIfNull(plates);
+        ArgumentNullException.ThrowIfNull(options);
+        ArgumentNullException.ThrowIfNull(settings);
+        if (plates.Distinct(ReferenceEqualityComparer.Instance).Count() != plates.Count)
+            throw new ArgumentException("Each plate must occur only once.", nameof(plates));
+
+        var plans = new List<AutomaticCutOffPlan>(plates.Count);
+        for (var index = 0; index < plates.Count; index++)
+        {
+            try
+            {
+                plans.Add(AutomaticCutOffPlanner.Create(plates[index], options, settings));
+            }
+            catch (ArgumentException error)
+            {
+                throw new ArgumentException($"Plate {index + 1}: {error.Message}", nameof(plates), error);
+            }
+        }
+        return plans.AsReadOnly();
+    }
+
+    /// <summary>
+    /// Replans all plates before changing any. A blocking plan returns without applying any
+    /// definitions; empty/unchanged plates are untouched. On failure, restores cutoff state
+    /// on every touched plate, reporting explicitly if any restoration also fails.
+    /// Returned plans describe the fresh proposal, not preview parts to accept into a plate.
+    /// </summary>
+    public static IReadOnlyList<AutomaticCutOffPlan> Apply(IReadOnlyList<Plate> plates,
+        AutomaticCutOffOptions options, CutOffSettings settings)
+    {
+        var plans = Create(plates, options, settings);
+        if (plans.Any(plan => plan.HasBlockingDiagnostics))
+            return plans;
+
+        var restoreActions = new List<(int PlateNumber, Action Restore)>();
+        try
+        {
+            for (var index = 0; index < plates.Count; index++)
+            {
+                var plan = plans[index];
+                if (plan.Definitions.Count == 0)
+                    continue;
+
+                var plate = plates[index];
+                // Register recovery before the first observable mutation, including AddRange.
+                restoreActions.Add((index + 1, CaptureRestore(plate, plan)));
+                plate.CutOffs.AddRange(plan.Definitions);
+                plate.RegenerateCutOffs(settings);
+            }
+        }
+        catch (Exception applyError)
+        {
+            var rollbackErrors = new List<Exception>();
+            for (var index = restoreActions.Count - 1; index >= 0; index--)
+            {
+                var saved = restoreActions[index];
+                try
+                {
+                    saved.Restore();
+                }
+                catch (Exception rollbackError)
+                {
+                    // A broken observer on one plate must not prevent recovery of the others.
+                    rollbackErrors.Add(new InvalidOperationException(
+                        $"Plate {saved.PlateNumber}: {rollbackError.Message}", rollbackError));
+                }
+            }
+            if (rollbackErrors.Count > 0)
+                throw new InvalidOperationException(
+                    $"Apply failed: {applyError.Message}\nRestoring cut-offs also failed: "
+                    + string.Join("; ", rollbackErrors.Select(e => e.Message))
+                    + "\nThe nest may be incomplete; review it before saving or cutting.",
+                    new AggregateException(new[] { applyError }.Concat(rollbackErrors)));
+
+            throw new InvalidOperationException(
+                $"No new cut-offs were retained; original cut-offs were restored. {applyError.Message}", applyError);
+        }
+        return plans;
+    }
+
+    private static Action CaptureRestore(Plate plate, AutomaticCutOffPlan plan)
+    {
+        // Regeneration replaces drawing programs and removes/reinserts cutoff parts.
+        // Save only that state; real parts, poses, programs and quantities stay untouched.
+        var programs = plate.CutOffs.Select(c => (CutOff: c, Program: c.Drawing.Program)).ToArray();
+        var parts = plate.Parts.Select((part, index) => (Part: part, Index: index))
+            .Where(p => p.Part.BaseDrawing.IsCutOff).ToArray();
+        return () =>
+        {
+            foreach (var definition in plan.Definitions)
+                plate.CutOffs.Remove(definition);
+            for (var index = plate.Parts.Count - 1; index >= 0; index--)
+            {
+                if (plate.Parts[index].BaseDrawing.IsCutOff)
+                    plate.Parts.RemoveAt(index);
+            }
+            foreach (var saved in programs)
+                saved.CutOff.Drawing.Program = saved.Program;
+            foreach (var saved in parts)
+                plate.Parts.Insert(saved.Index, saved.Part);
+        };
+    }
+}

OpenNest.Core/AutomaticCutOffPlanner.cs

@@ -0,0 +1,384 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenNest.CNC;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest;
+
+public sealed class AutomaticCutOffOptions
+{
+    /// <summary>
+    /// Nominal distance between vertical cut lines in model units. Must be finite and
+    /// greater than AutomaticCutOffPlanner.MinimumSpacing; Create also bounds candidate count.
+    /// </summary>
+    public double Spacing { get; set; }
+
+    /// <summary>
+    /// Minimum retained-tail length along X in model units. Zero permits any positive tail.
+    /// The desktop default is 12 inches (304.8 mm).
+    /// </summary>
+    public double MinimumTailLength { get; set; }
+}
+
+public enum AutomaticCutOffDiagnosticCode
+{
+    ExistingCutOff,
+    LimitedCutOffConflict,
+    EmptyCut,
+    SegmentedCut,
+    NoSafeTailSeparator,
+    TailBelowMinimum,
+}
+
+public sealed record AutomaticCutOffDiagnostic(
+    AutomaticCutOffDiagnosticCode Code, string Message, bool IsBlocking = false, double? X = null);
+
+/// <summary>
+/// Detached proposal. Collections are read-only; contained definitions/preview parts belong
+/// to the caller. Never accept a blocked plan or a preview made for an older layout/settings.
+/// </summary>
+public sealed class AutomaticCutOffPlan
+{
+    /// <summary>Only new, usable definitions; existing equivalent definitions are not returned.</summary>
+    public IReadOnlyList<CutOff> Definitions { get; internal set; } = Array.Empty<CutOff>();
+
+    /// <summary>Detached display parts, in the same order as Definitions. Not for acceptance.</summary>
+    public IReadOnlyList<Part> PreviewParts { get; internal set; } = Array.Empty<Part>();
+
+    public IReadOnlyList<AutomaticCutOffDiagnostic> Diagnostics { get; internal set; } =
+        Array.Empty<AutomaticCutOffDiagnostic>();
+
+    /// <summary>Furthest real-part X distance from the origin, excluding cut-off parts.</summary>
+    public double OccupiedSpan { get; internal set; }
+
+    /// <summary>
+    /// Distance to the verified separator, or full sheet length when no separated tail can
+    /// be claimed. Zero on empty sheets. This is not a disconnected-scrap-size guarantee.
+    /// </summary>
+    public double UsedSpan { get; internal set; }
+
+    /// <summary>Length beyond a verified separator, otherwise zero (also on empty sheets).</summary>
+    public double TailLength { get; internal set; }
+
+    /// <summary>Signed X coordinate of a verified new or equivalent existing separator.</summary>
+    public double? TailSeparatorX { get; internal set; }
+
+    /// <summary>True only for a verified full-width separator, never just a nominal boundary.</summary>
+    public bool HasSeparatedTail => TailSeparatorX.HasValue;
+
+    public bool HasBlockingDiagnostics => Diagnostics.Any(d => d.IsBlocking);
+}
+
+/// <summary>Pure proposals for vertical scrap cuts, measured in the plate's model units.</summary>
+public static class AutomaticCutOffPlanner
+{
+    public const double GeometryTolerance = Tolerance.Epsilon;
+    public const double MinimumSpacing = 2 * GeometryTolerance;
+    public const int MaximumCandidateCount = 10000;
+
+    /// <summary>
+    /// Plans without changing the plate, its parts, or existing cut-off definitions/programs.
+    /// Invalid inputs throw ArgumentException. Blocking diagnostics return no definitions.
+    /// Accept by adding Definitions to Plate.CutOffs and calling RegenerateCutOffs with the
+    /// same settings, only while the layout is unchanged. Do not add PreviewParts to the plate.
+    /// Nominal spacing is not a guarantee of fully disconnected, hopper-sized scrap.
+    /// </summary>
+    public static AutomaticCutOffPlan Create(Plate plate, AutomaticCutOffOptions options,
+        CutOffSettings settings)
+    {
+        ArgumentNullException.ThrowIfNull(plate);
+        ArgumentNullException.ThrowIfNull(options);
+        ArgumentNullException.ThrowIfNull(settings);
+        ValidateInputs(plate, options, settings);
+        var bounds = plate.BoundingBox(false);
+        Require(ValidBox(bounds) && double.IsFinite(bounds.Top + settings.Overtravel),
+            "Physical sheet bounds and overtravel must be finite.", nameof(plate));
+
+        var sign = plate.Quadrant is 2 or 3 ? -1 : 1;
+        var occupied = 0.0;
+        var hasParts = false;
+        foreach (var part in plate.Parts)
+        {
+            Require(part?.BaseDrawing != null, "Every part must have a drawing.", nameof(plate));
+            if (part.BaseDrawing.IsCutOff)
+                continue;
+
+            occupied = System.Math.Max(occupied, ValidatePart(part, bounds, sign));
+            hasParts = true;
+        }
+        if (!hasParts)
+            return new AutomaticCutOffPlan();
+
+        // Use distances from the coordinate origin, not the sheet's lower-left corner.
+        var length = plate.Size.Length;
+        occupied = System.Math.Min(occupied, length);
+        var separator = occupied + System.Math.Max(plate.PartSpacing, settings.PartClearance)
+            + GeometryTolerance;
+        var hasTailCandidate = double.IsFinite(separator) && separator < length - GeometryTolerance;
+        var usedSpan = hasTailCandidate ? separator : length;
+        var candidateCount = System.Math.Ceiling(usedSpan / options.Spacing);
+        Require(double.IsFinite(candidateCount) && candidateCount <= MaximumCandidateCount,
+            $"Spacing would generate more than {MaximumCandidateCount} cut-off candidates.", nameof(options));
+
+        // Validate and bound the candidate count before preparing geometry or allocating lines.
+        ValidateExisting(plate, bounds, settings);
+        var cache = Plate.BuildPerimeterCache(plate);
+        var definitions = new List<CutOff>();
+        var diagnostics = new List<AutomaticCutOffDiagnostic>();
+        var separated = false;
+        var separatorX = (double?)null;
+
+        // Multiplication by an integer avoids drift from repeated floating-point addition.
+        for (var index = 1; index <= (int)candidateCount; index++)
+        {
+            var distance = index * options.Spacing;
+            if (distance >= usedSpan - GeometryTolerance)
+                break;
+            AddCandidate(sign * distance, false);
+        }
+        if (hasTailCandidate)
+        {
+            if (length - separator >= options.MinimumTailLength)
+                AddCandidate(sign * separator, true);
+            else
+                diagnostics.Add(new AutomaticCutOffDiagnostic(
+                    AutomaticCutOffDiagnosticCode.TailBelowMinimum,
+                    "The proposed tail is shorter than the minimum tail length; the final separator was skipped. "
+                    + "Other automatic lines and existing cut-offs are unchanged. No retained tail is claimed.",
+                    X: sign * separator));
+        }
+
+        if (diagnostics.Any(d => d.IsBlocking))
+        {
+            // A partial proposal must not accidentally be accepted around a manual conflict.
+            definitions.Clear();
+            separated = false;
+            separatorX = null;
+        }
+
+        return new AutomaticCutOffPlan
+        {
+            Definitions = definitions.AsReadOnly(),
+            PreviewParts = definitions.Select(c => new Part(c.Drawing)).ToList().AsReadOnly(),
+            Diagnostics = diagnostics.AsReadOnly(),
+            OccupiedSpan = occupied,
+            UsedSpan = separated ? System.Math.Abs(separatorX.Value) : length,
+            TailLength = separated ? length - System.Math.Abs(separatorX.Value) : 0,
+            TailSeparatorX = separatorX,
+        };
+
+        void AddCandidate(double x, bool isSeparator)
+        {
+            var matches = plate.CutOffs.Where(c => c.Axis == CutOffAxis.Vertical &&
+                Near(c.Position.X, x)).ToList();
+            if (matches.Any(c => !FullSpanLimits(c, bounds, settings)))
+            {
+                diagnostics.Add(new AutomaticCutOffDiagnostic(
+                    AutomaticCutOffDiagnosticCode.LimitedCutOffConflict,
+                    "A same-line manual cut has different limits. Manual review is required; no cuts may be applied.",
+                    true, x));
+                if (isSeparator)
+                    WarnNoSeparator(x);
+                return;
+            }
+
+            // Even a duplicate must be regenerated detached with CURRENT settings. Its live
+            // drawing can be stale, and a tolerance-close line can intersect a part at the tail.
+            var existing = matches.FirstOrDefault();
+            var candidate = existing == null
+                ? new CutOff(new Vector(x, 0), CutOffAxis.Vertical)
+                : new CutOff(existing.Position, existing.Axis)
+                { StartLimit = existing.StartLimit, EndLimit = existing.EndLimit };
+            candidate.Regenerate(plate, settings, cache);
+            var program = candidate.Drawing.Program;
+            var usable = HasUsableSegments(program);
+            if (existing != null)
+                diagnostics.Add(new AutomaticCutOffDiagnostic(
+                    AutomaticCutOffDiagnosticCode.ExistingCutOff,
+                    "An equivalent full-span cut-off already exists; no duplicate was added.", X: x));
+            if (!usable)
+                diagnostics.Add(new AutomaticCutOffDiagnostic(
+                    AutomaticCutOffDiagnosticCode.EmptyCut,
+                    "The line has no usable cut segments after part clearance and minimum-length filtering; it is not a partition.",
+                    X: x));
+
+            if (isSeparator)
+            {
+                if (!usable || !IsFullSpanProgram(program, bounds))
+                {
+                    WarnNoSeparator(x);
+                    return;
+                }
+                separated = true;
+                separatorX = candidate.Position.X;
+            }
+            else if (usable && !IsFullSpanProgram(program, bounds))
+                diagnostics.Add(new AutomaticCutOffDiagnostic(
+                    AutomaticCutOffDiagnosticCode.SegmentedCut,
+                    "Part clearance or segment filtering interrupts this line; nominal spacing does not guarantee disconnected scrap.",
+                    X: x));
+
+            if (usable && existing == null)
+                definitions.Add(candidate);
+        }
+
+        void WarnNoSeparator(double x) => diagnostics.Add(new AutomaticCutOffDiagnostic(
+            AutomaticCutOffDiagnosticCode.NoSafeTailSeparator,
+            "No safe full-width tail separator survives the current settings. No separated tail is claimed; review manually.",
+            X: x));
+    }
+
+    private static void ValidateInputs(Plate plate, AutomaticCutOffOptions options, CutOffSettings settings)
+    {
+        Require(double.IsFinite(options.Spacing) && options.Spacing > MinimumSpacing,
+            $"Spacing must be finite and greater than {MinimumSpacing} model units.", nameof(options));
+        Require(Nonnegative(options.MinimumTailLength),
+            "Minimum tail length must be finite and nonnegative.", nameof(options));
+        Require(double.IsFinite(plate.Size.Length) && plate.Size.Length > 0 &&
+            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));
+        Require(Nonnegative(plate.PartSpacing), "Part spacing must be finite and nonnegative.", nameof(plate));
+        Require(Nonnegative(settings.PartClearance) && Nonnegative(settings.MinSegmentLength) &&
+            Nonnegative(settings.Overtravel), "Cut-off settings must be finite and nonnegative.", nameof(settings));
+        Require(Enum.IsDefined(settings.CutDirection), "Unknown cut direction.", nameof(settings));
+        Require(plate.Parts != null && plate.CutOffs != null,
+            "Plate parts and cut-off collections are required.", nameof(plate));
+    }
+
+    private static double ValidatePart(Part part, Box sheet, int sign)
+    {
+        Require(Finite(part.Location) && double.IsFinite(part.Rotation),
+            "Part pose must be finite.", "plate");
+        ValidateProgram(part.Program, new HashSet<Program>());
+        var box = part.Program.BoundingBox();
+        box.Offset(part.Location);
+        Require(ValidBox(box) && box.Length > 0 && box.Width > 0,
+            "Real parts must have finite, nonempty geometry.", "plate");
+        var cached = part.BoundingBox;
+        Require(ValidBox(cached) && Near(box.Left, cached.Left) && Near(box.Right, cached.Right) &&
+            Near(box.Bottom, cached.Bottom) && Near(box.Top, cached.Top),
+            "Part geometry has stale bounds; update it before planning.", "plate");
+        Require(Inside(box, sheet), "Part geometry extends outside the physical sheet.", "plate");
+
+        // Checking raw coordinates above prevents NaNs being hidden by min/max comparisons.
+        // Checking converted entities catches overflowing incremental moves and curve bounds.
+        var hasMaterial = false;
+        var occupied = sign > 0 ? box.Right : -box.Left;
+        var roundoff = CutOff.GetBoundsRoundoff(part);
+        foreach (var entity in ConvertProgram.ToGeometry(part.Program))
+        {
+            var entityBox = entity.BoundingBox;
+            Require(ValidBox(entityBox), "Part contains invalid converted geometry.", "plate");
+            if (!SpecialLayers.IsMaterial(entity.Layer))
+                continue;
+            entityBox = entityBox.Translate(part.Location);
+            // Permit only bounded floating-point roundoff, with the same conservative
+            // padding in CutOff's broad phase and fallback. Geometry-scale protrusions
+            // (including refitted arc centers) are still rejected, even below epsilon.
+            Require(entityBox.Left >= cached.Left - roundoff && entityBox.Right <= cached.Right + roundoff &&
+                entityBox.Bottom >= cached.Bottom - roundoff && entityBox.Top <= cached.Top + roundoff,
+                "Converted material extends outside cached part bounds; repair it before planning.", "plate");
+            Require(Inside(entityBox, sheet), "Part geometry extends outside the physical sheet.", "plate");
+            occupied = System.Math.Max(occupied, sign > 0 ? entityBox.Right : -entityBox.Left);
+            hasMaterial |= entityBox.Length > 0 || entityBox.Width > 0;
+        }
+        Require(hasMaterial, "Real parts must contain material geometry.", "plate");
+        return occupied;
+    }
+
+    private static void ValidateProgram(Program program, HashSet<Program> path)
+    {
+        Require(program?.Codes != null && path.Count < 64 && path.Add(program),
+            "Part program is missing, recursive, or nested too deeply.", "plate");
+        foreach (var code in program.Codes)
+        {
+            Require(code != null, "Part program contains a missing instruction.", "plate");
+            if (code is Motion motion)
+                Require(Finite(motion.EndPoint), "Part motion coordinates must be finite.", "plate");
+            if (code is ArcMove arc)
+                Require(Finite(arc.CenterPoint) && Enum.IsDefined(arc.Rotation),
+                    "Part arc geometry must be finite with a valid direction.", "plate");
+            if (code is SubProgramCall call)
+            {
+                Require(Finite(call.Offset) && double.IsFinite(call.Rotation),
+                    "Part sub-program pose must be finite.", "plate");
+                ValidateProgram(call.Program, path);
+            }
+        }
+        path.Remove(program);
+    }
+
+    private static void ValidateExisting(Plate plate, Box bounds, CutOffSettings settings)
+    {
+        foreach (var cut in plate.CutOffs)
+        {
+            Require(cut != null && Enum.IsDefined(cut.Axis) && Finite(cut.Position) &&
+                (!cut.StartLimit.HasValue || double.IsFinite(cut.StartLimit.Value)) &&
+                (!cut.EndLimit.HasValue || double.IsFinite(cut.EndLimit.Value)),
+                "Existing cut-off definitions must be finite with a valid axis.", nameof(plate));
+            var start = cut.StartLimit ?? (cut.Axis == CutOffAxis.Vertical ? bounds.Bottom : bounds.Left);
+            var end = cut.EndLimit ?? ((cut.Axis == CutOffAxis.Vertical ? bounds.Top : bounds.Right)
+                + settings.Overtravel);
+            Require(double.IsFinite(end) && start < end,
+                "Existing cut-off limits must be finite and ordered.", nameof(plate));
+        }
+    }
+
+    private static bool FullSpanLimits(CutOff cut, Box bounds, CutOffSettings settings) =>
+        Near(cut.StartLimit ?? bounds.Bottom, bounds.Bottom) &&
+        Near(cut.EndLimit ?? (bounds.Top + settings.Overtravel), bounds.Top + settings.Overtravel);
+
+    private static bool HasUsableSegments(Program program)
+    {
+        if (program.Codes.Count == 0 || program.Codes.Count % 2 != 0)
+            return false;
+        for (var i = 0; i < program.Codes.Count; i += 2)
+        {
+            if (program.Codes[i] is not RapidMove from || program.Codes[i + 1] is not LinearMove to ||
+                !Finite(from.EndPoint) || !Finite(to.EndPoint) ||
+                !Near(from.EndPoint.X, to.EndPoint.X) ||
+                System.Math.Abs(from.EndPoint.Y - to.EndPoint.Y) <= GeometryTolerance)
+                return false;
+        }
+        return true;
+    }
+
+    private static bool IsFullSpanProgram(Program program, Box bounds)
+    {
+        // No gaps, bridges, or filtered middle segments can separate the tail.
+        if (program.Codes.Count != 2 || program.Codes[0] is not RapidMove from ||
+            program.Codes[1] is not LinearMove to)
+            return false;
+        return System.Math.Min(from.EndPoint.Y, to.EndPoint.Y) <= bounds.Bottom + GeometryTolerance &&
+            System.Math.Max(from.EndPoint.Y, to.EndPoint.Y) >= bounds.Top - GeometryTolerance;
+    }
+
+    private static bool ValidBox(Box box) => box != null && Finite(box.Location) &&
+        Nonnegative(box.Length) && Nonnegative(box.Width) &&
+        double.IsFinite(box.Right) && double.IsFinite(box.Top);
+
+    private static bool Inside(Box box, Box sheet) =>
+        box.Left >= sheet.Left - GeometryTolerance && box.Right <= sheet.Right + GeometryTolerance &&
+        box.Bottom >= sheet.Bottom - GeometryTolerance && box.Top <= sheet.Top + GeometryTolerance;
+
+    private static bool Finite(Vector point) => double.IsFinite(point.X) && double.IsFinite(point.Y);
+    private static bool Nonnegative(double value) => double.IsFinite(value) && value >= 0;
+    private static bool Near(double a, double b)
+    {
+        // An exact tolerance-sized offset can round just above epsilon after subtraction.
+        // Allow two representational steps, not a geometry-scale relative tolerance.
+        var magnitude = System.Math.Max(System.Math.Abs(a), System.Math.Abs(b));
+        var step = System.Math.BitIncrement(magnitude) - magnitude;
+        return System.Math.Abs(a - b) <= GeometryTolerance + (double.IsFinite(step) ? 2 * step : 0);
+    }
+
+    private static void Require(bool valid, string message, string parameter)
+    {
+        if (!valid)
+            throw new ArgumentException(message, parameter);
+    }
+}

OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs

@@ -367,19 +367,26 @@ namespace OpenNest.CNC.CuttingStrategy
                 return;
             }
 
-            program.Codes.AddRange(leadIn.Generate(point, normal, winding));
+            leadIn = ResolveLeadIn(shape, point, entity, contourType, leadIn, winding,
+                Parameters.PierceClearance, out var leadInNormal);
+            program.Codes.AddRange(leadIn.Generate(point, leadInNormal, winding));
 
             var reindexedShape = shape.ReindexAt(point, entity);
 
-            if (
+            var tabbed = Parameters.TabsEnabled
-                Parameters.TabsEnabled
                 && Parameters.TabConfig != null
-                && contourType == ContourType.External
+                && contourType == ContourType.External;
-            )
+            if (tabbed)
                 reindexedShape = TrimShapeForTab(reindexedShape, point, Parameters.TabConfig.Size);
 
+            // A tab leaves the contour short of the corner; a run-out through it would cut the tab.
+            var leadOutNormal = normal;
+            if (!tabbed)
+                leadOut = ResolveLeadOut(shape, point, entity, contourType, leadOut, winding,
+                    Parameters.PierceClearance, out leadOutNormal);
+
             program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
-            program.Codes.AddRange(leadOut.Generate(point, normal, winding));
+            program.Codes.AddRange(leadOut.Generate(point, leadOutNormal, winding));
         }
 
         private void EmitScribeContours(Program program, List<Entity> scribeEntities)
@@ -436,6 +443,259 @@ namespace OpenNest.CNC.CuttingStrategy
             return ContourType.Internal;
         }
 
+        /// <summary>
+        /// Uses the inward angle bisector for straight lead-ins at cutout corners.
+        /// Edge interiors and other lead-in styles keep the entity normal. Shared
+        /// by program generation and the manual placement preview.
+        /// </summary>
+        public static double ComputeLeadInNormal(
+            Shape shape,
+            Vector point,
+            Entity entity,
+            ContourType contourType,
+            LeadIn leadIn,
+            RotationType winding = RotationType.CW
+        )
+        {
+            var normal = ComputeNormal(point, entity, contourType, winding);
+            if (contourType != ContourType.Internal || leadIn is not LineLeadIn
+                || !TryGetCorner(shape, point, entity, out var corner))
+                return normal;
+
+            return BisectCorner(point, corner, contourType, winding) ?? normal;
+        }
+
+        /// <summary>
+        /// Returns the lead-in to emit at <paramref name="point"/> and the normal to
+        /// generate it with. At a corner of an outside perimeter, a straight
+        /// (<see cref="LineLeadIn"/>) lead-in extends the edge cut first so the torch
+        /// enters on that edge's line, provided the pierce keeps
+        /// <paramref name="pierceClearance"/> from the contour; the approach angle is
+        /// ignored there. Otherwise it is perpendicular to the edge cut first, and at a
+        /// reflex corner it bisects the notch. The result does not depend on which of
+        /// the two edges meeting at the corner was picked. Other styles and contour
+        /// types keep <see cref="ComputeLeadInNormal"/>.
+        /// </summary>
+        public static LeadIn ResolveLeadIn(
+            Shape shape,
+            Vector point,
+            Entity entity,
+            ContourType contourType,
+            LeadIn leadIn,
+            RotationType winding,
+            double pierceClearance,
+            out double normal
+        )
+        {
+            normal = ComputeLeadInNormal(shape, point, entity, contourType, leadIn, winding);
+            if (contourType != ContourType.External || leadIn is not LineLeadIn line
+                || !TryGetCorner(shape, point, entity, out var corner))
+                return leadIn;
+
+            switch (ClassifyCorner(corner, winding))
+            {
+                case CornerKind.Convex:
+                    var pierce = point - corner.TangentOut * line.Length;
+                    if (IsClearStraightLead(shape, point, pierce, pierceClearance))
+                    {
+                        normal = Angle.NormalizeRad((-corner.TangentOut).Angle());
+                        return new LineLeadIn { Length = line.Length, ApproachAngle = 90 };
+                    }
+                    normal = ComputeNormal(point, corner.Outgoing, contourType, winding);
+                    return leadIn;
+                case CornerKind.Smooth:
+                    normal = ComputeNormal(point, corner.Outgoing, contourType, winding);
+                    return leadIn;
+                case CornerKind.Reflex:
+                    normal = BisectCorner(point, corner, contourType, winding) ?? normal;
+                    return leadIn;
+                default:
+                    return leadIn;
+            }
+        }
+
+        /// <summary>
+        /// Lead-out counterpart of <see cref="ResolveLeadIn"/>. At a convex outside
+        /// perimeter corner a <see cref="LineLeadOut"/> runs straight on past the corner
+        /// along the edge cut last, when its end keeps <paramref name="clearance"/> from
+        /// the contour; otherwise it is perpendicular to that edge. At a reflex corner it
+        /// bisects the notch. Other styles and contour types keep the entity normal.
+        /// </summary>
+        public static LeadOut ResolveLeadOut(
+            Shape shape,
+            Vector point,
+            Entity entity,
+            ContourType contourType,
+            LeadOut leadOut,
+            RotationType winding,
+            double clearance,
+            out double normal
+        )
+        {
+            normal = ComputeNormal(point, entity, contourType, winding);
+            if (contourType != ContourType.External || leadOut is not LineLeadOut line
+                || !TryGetCorner(shape, point, entity, out var corner))
+                return leadOut;
+
+            switch (ClassifyCorner(corner, winding))
+            {
+                case CornerKind.Convex:
+                    var end = point + corner.TangentIn * line.Length;
+                    if (IsClearStraightLead(shape, point, end, clearance))
+                    {
+                        normal = Angle.NormalizeRad(corner.TangentIn.Angle());
+                        return new LineLeadOut { Length = line.Length, ApproachAngle = 90 };
+                    }
+                    normal = ComputeNormal(point, corner.Incoming, contourType, winding);
+                    return leadOut;
+                case CornerKind.Smooth:
+                    normal = ComputeNormal(point, corner.Incoming, contourType, winding);
+                    return leadOut;
+                case CornerKind.Reflex:
+                    normal = BisectCorner(point, corner, contourType, winding) ?? normal;
+                    return leadOut;
+                default:
+                    return leadOut;
+            }
+        }
+
+        private enum CornerKind
+        {
+            Convex,
+            Reflex,
+            Smooth,
+            Cusp,
+        }
+
+        /// <summary>A contour vertex: the entity cut into it and the one cut away from it.</summary>
+        private readonly record struct ContourCorner(
+            Entity Incoming,
+            Entity Outgoing,
+            Vector TangentIn,
+            Vector TangentOut
+        );
+
+        private static bool TryGetCorner(Shape shape, Vector point, Entity entity, out ContourCorner corner)
+        {
+            corner = default;
+            if (entity is not (Line or Arc) || entity.Length <= Tolerance.Epsilon
+                || shape.Entities.Count < 2 || !shape.IsClosed())
+                return false;
+
+            var index = shape.Entities.IndexOf(entity);
+            if (index < 0)
+                return false;
+
+            var atStart = point.DistanceTo(EntityStartPoint(entity)) <= Tolerance.Epsilon;
+            if (!atStart && point.DistanceTo(EntityEndPoint(entity)) > Tolerance.Epsilon)
+                return false;
+
+            var adjacentIndex = atStart
+                ? (index + shape.Entities.Count - 1) % shape.Entities.Count
+                : (index + 1) % shape.Entities.Count;
+            var adjacent = shape.Entities[adjacentIndex];
+            var adjacentPoint = atStart ? EntityEndPoint(adjacent) : EntityStartPoint(adjacent);
+
+            if (adjacent is not (Line or Arc) || adjacent.Length <= Tolerance.Epsilon
+                || point.DistanceTo(adjacentPoint) > Tolerance.Epsilon)
+                return false;
+
+            var incoming = atStart ? adjacent : entity;
+            var outgoing = atStart ? entity : adjacent;
+            var tangentIn = TravelTangent(incoming, point);
+            var tangentOut = TravelTangent(outgoing, point);
+            if (!IsFinite(tangentIn) || !IsFinite(tangentOut))
+                return false;
+
+            corner = new ContourCorner(incoming, outgoing, tangentIn, tangentOut);
+            return true;
+        }
+
+        /// <summary>Unit direction of travel along a line or arc at a point on it.</summary>
+        private static Vector TravelTangent(Entity entity, Vector point)
+        {
+            if (entity is Line line)
+                return (line.EndPoint - line.StartPoint).Normalize();
+
+            var arc = (Arc)entity;
+            var radial = (point - arc.Center).Normalize();
+            return arc.IsReversed ? new Vector(radial.Y, -radial.X) : new Vector(-radial.Y, radial.X);
+        }
+
+        private static bool IsFinite(Vector v) => double.IsFinite(v.X) && double.IsFinite(v.Y);
+
+        /// <summary>
+        /// Convex corners point away from the part (interior angle under 180 degrees).
+        /// 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)
+        {
+            var cross = corner.TangentIn.X * corner.TangentOut.Y - corner.TangentIn.Y * corner.TangentOut.X;
+            var dot = corner.TangentIn.DotProduct(corner.TangentOut);
+            var turn = winding == RotationType.CCW ? cross : -cross;
+
+            if (System.Math.Abs(turn) <= Tolerance.Epsilon)
+                return dot > 0 ? CornerKind.Smooth : CornerKind.Cusp;
+
+            return turn > 0 ? CornerKind.Convex : CornerKind.Reflex;
+        }
+
+        private static double? BisectCorner(
+            Vector point,
+            ContourCorner corner,
+            ContourType contourType,
+            RotationType winding
+        )
+        {
+            var normal = ComputeNormal(point, corner.Outgoing, contourType, winding);
+            var adjacentNormal = ComputeNormal(point, corner.Incoming, contourType, winding);
+            // Sum unit normals rather than averaging angles (which fails at 0/2π).
+            // Winding makes this point into the scrap even at reflex corners.
+            var x = System.Math.Cos(normal) + System.Math.Cos(adjacentNormal);
+            var y = System.Math.Sin(normal) + System.Math.Sin(adjacentNormal);
+            if (!double.IsFinite(x) || !double.IsFinite(y)
+                || x * x + y * y <= Tolerance.Epsilon * Tolerance.Epsilon)
+                return null; // Opposing normals at a cusp have no unique bisector.
+
+            return Angle.NormalizeRad(System.Math.Atan2(y, x));
+        }
+
+        /// <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
+        /// crosses the contour nowhere but at the corner.
+        /// </summary>
+        private static bool IsClearStraightLead(Shape shape, Vector corner, Vector end, double clearance)
+        {
+            if (!IsFinite(end) || end.DistanceTo(corner) <= Tolerance.Epsilon)
+                return false;
+
+            var nearest = shape.ClosestPointTo(end, out _);
+            if (nearest.DistanceTo(end) < System.Math.Max(clearance, 0) - Tolerance.Epsilon)
+                return false;
+
+            if (shape.Intersects(new Line(end, corner), out var crossings))
+            {
+                foreach (var crossing in crossings)
+                {
+                    if (crossing.DistanceTo(corner) > Tolerance.ChainTolerance)
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static Vector EntityEndPoint(Entity entity)
+        {
+            if (entity is Line line)
+                return line.EndPoint;
+            if (entity is Arc arc)
+                return arc.EndPoint();
+            return Vector.Invalid;
+        }
+
         public static double ComputeNormal(
             Vector point,
             Entity entity,

OpenNest.Core/CNC/Program.cs

@@ -90,6 +90,9 @@ namespace OpenNest.CNC
 
             SetModeAbs();
 
+            // Several calls can share one sub-program (identical holes); rotate each once.
+            var rotatedSubPrograms = new HashSet<Program>(ReferenceEqualityComparer.Instance);
+
             for (int i = 0; i < Codes.Count; ++i)
             {
                 var code = Codes[i];
@@ -110,7 +113,7 @@ namespace OpenNest.CNC
                         );
                     }
 
-                    if (subpgm.Program != null)
+                    if (subpgm.Program != null && rotatedSubPrograms.Add(subpgm.Program))
                         subpgm.Program.Rotate(angle, origin);
                 }
 
@@ -519,8 +522,31 @@ namespace OpenNest.CNC
             foreach (var kvp in Variables)
                 pgm.Variables[kvp.Key] = kvp.Value;
 
+            // The copy owns its sub-programs: rotating it must never turn the source's holes.
+            // Calls that shared one sub-program keep sharing one copy.
+            Dictionary<Program, Program> subCopies = null;
+
+            Program CopyOf(Program sub)
+            {
+                subCopies ??= new Dictionary<Program, Program>(ReferenceEqualityComparer.Instance);
+
+                if (!subCopies.TryGetValue(sub, out var copy))
+                {
+                    copy = (Program)sub.Clone();
+                    subCopies[sub] = copy;
+                }
+
+                return copy;
+            }
+
             foreach (var kvp in SubPrograms)
-                pgm.SubPrograms[kvp.Key] = (Program)kvp.Value.Clone();
+                pgm.SubPrograms[kvp.Key] = CopyOf(kvp.Value);
+
+            foreach (var code in codes)
+            {
+                if (code is SubProgramCall call && call.Program != null)
+                    call.BindProgram(CopyOf(call.Program));
+            }
 
             return pgm;
         }

OpenNest.Core/CNC/RapidEnumerator.cs

@@ -7,20 +7,42 @@ namespace OpenNest.CNC
     {
         public readonly record struct Segment(Vector From, Vector To);
 
+        /// <summary>
+        /// Enumerates plate rapids in cutting order, advancing through all cutting
+        /// motions before connecting to the next part (including scrap cutoffs).
+        /// </summary>
+        public static List<Segment> Enumerate(IEnumerable<Part> parts)
+        {
+            var results = new List<Segment>();
+            var pos = Vector.Zero;
+
+            foreach (var part in parts)
+                pos = AppendProgram(part.Program, part.Location, pos, results);
+
+            return results;
+        }
+
         public static List<Segment> Enumerate(Program pgm, Vector basePos, Vector startPos)
         {
             var results = new List<Segment>();
+            AppendProgram(pgm, basePos, startPos, results);
+            return results;
+        }
 
+        private static Vector AppendProgram(Program pgm, Vector basePos, Vector startPos, List<Segment> results)
+        {
             // Draw the rapid from the previous tool position to the program's first
-            // pierce point. This also primes pos so the interior walk interprets
+            // pierce point. The walk then starts at the program origin (basePos), not
-            // Incremental deltas from the correct absolute location (basePos), which
+            // the pierce: the skipped first rapid still advances pos, so starting at
-            // matters for raw pre-lead-in programs that are emitted Incremental.
+            // the pierce would apply a nonzero Incremental first delta twice (as in
+            // lead-in programs) and shift every later rapid by it.
             var firstPierce = FirstPiercePoint(pgm, basePos);
             results.Add(new Segment(startPos, firstPierce));
 
-            var pos = firstPierce;
+            var pos = basePos;
             Walk(pgm, basePos, ref pos, skipFirst: true, results);
-            return results;
+            // The last rapid ends at a pierce, not necessarily the final tool position.
+            return pos;
         }
 
         private static Vector FirstPiercePoint(Program pgm, Vector basePos)

OpenNest.Core/CNC/SubProgramCall.cs

@@ -1,4 +1,4 @@
-using System.Text;
+using System.Text;
 using OpenNest.Geometry;
 using OpenNest.Math;
 
@@ -79,12 +79,28 @@ namespace OpenNest.CNC
         }
 
         /// <summary>
-        /// Gets a shallow copy.
+        /// Gets a shallow copy that references the same program. Copies the fields
+        /// directly: going through the setters would re-align (rotate) the shared program.
         /// </summary>
         /// <returns></returns>
         public ICode Clone()
         {
-            return new SubProgramCall(program, Rotation) { Id = Id, Offset = Offset };
+            return new SubProgramCall
+            {
+                program = program,
+                rotation = rotation,
+                Id = Id,
+                Offset = Offset,
+            };
+        }
+
+        /// <summary>
+        /// Points the call at <paramref name="copy"/>, a copy of its current program, without
+        /// re-aligning its rotation: the copy already has the geometry the call executes.
+        /// </summary>
+        internal void BindProgram(Program copy)
+        {
+            program = copy;
         }
 
         public override string ToString()

OpenNest.Core/CutOff.cs

@@ -135,8 +135,15 @@ namespace OpenNest
         )
         {
             var bb = part.BoundingBox;
+            var roundoff = GetBoundsRoundoff(part);
             var (partMin, partMax) = AxisBounds(bb, clearance);
             var (partStart, partEnd) = CrossAxisBounds(bb, clearance);
+            // Match the planner's representational allowance in BOTH pruning and
+            // fallback exclusions. Tolerating it only in validation could cut an edge.
+            partMin -= roundoff;
+            partMax += roundoff;
+            partStart -= roundoff;
+            partEnd += roundoff;
 
             if (cutPosition < partMin || cutPosition > partMax)
                 return EmptyExclusions;
@@ -157,6 +164,25 @@ namespace OpenNest
             return new List<(double Start, double End)> { (partStart, partEnd) };
         }
 
+        /// <summary>
+        /// Bounds reconstructed as (local minimum + placement) + size can differ
+        /// from translated material endpoints by a few floating-point steps. This
+        /// is not a geometry tolerance: cap it well below epsilon so inconsistent
+        /// arcs still require repair. Do not change shared Part bounds or programs.
+        /// </summary>
+        internal static double GetBoundsRoundoff(Part part)
+        {
+            var bb = part.BoundingBox;
+            var magnitude = System.Math.Max(System.Math.Abs(bb.Left), System.Math.Abs(bb.Right));
+            magnitude = System.Math.Max(magnitude,
+                System.Math.Max(System.Math.Abs(bb.Bottom), System.Math.Abs(bb.Top)));
+            magnitude = System.Math.Max(magnitude, System.Math.Max(bb.Length, bb.Width));
+            magnitude = System.Math.Max(magnitude,
+                System.Math.Max(System.Math.Abs(part.Location.X), System.Math.Abs(part.Location.Y)));
+            var step = System.Math.BitIncrement(magnitude) - magnitude;
+            return double.IsFinite(step) ? System.Math.Min(8 * step, Math.Tolerance.Epsilon / 4) : 0;
+        }
+
         private List<(double Start, double End)> IntersectPerimeter(
             Entity perimeter,
             double cutPosition,
@@ -191,6 +217,15 @@ namespace OpenNest
             if (coords.Count % 2 != 0)
                 return null;
 
+            // Intersects reports both incident edges at a shared vertex. Such hits may be
+            // crossings or tangencies, so neither pairing nor deduplicating them preserves
+            // inside/outside parity. Fall back to the clearance-expanded part bounds.
+            for (var i = 1; i < coords.Count; i++)
+            {
+                if (coords[i] - coords[i - 1] <= Math.Tolerance.Epsilon)
+                    return null;
+            }
+
             var padding = usedOffset ? 0 : clearance;
             var result = new List<(double Start, double End)>();
             for (var i = 0; i < coords.Count; i += 2)

OpenNest.Core/Diagnostics/OverlapAutoCheckScheduler.cs

@@ -0,0 +1,80 @@
+namespace OpenNest.Diagnostics;
+
+public enum OverlapAutoCheckStep { None, Wait, Check }
+
+/// <summary>
+/// UI-thread debounce policy for automatic overlap rechecks; the host owns the timer.
+/// Restart the quiet-period timer whenever <see cref="Observe"/> returns true, and call
+/// <see cref="Elapsed"/> when it fires. A check starts only after the ordered layout stamp
+/// has stayed unchanged for a whole quiet period with no interaction in progress.
+/// A canceled or failed request is not retried until the layout differs from the one it
+/// started from, so cancellation is respected and a failing layout cannot loop.
+/// </summary>
+public sealed class OverlapAutoCheckScheduler
+{
+    private OverlapGeometryStamp pending;
+    private OverlapGeometryStamp lastRequest;
+
+    public bool IsWaiting => pending != null;
+
+    /// <summary>
+    /// Call after the report state's freshness check. True means (re)start the quiet-period
+    /// timer; false means leave it as it is.
+    /// </summary>
+    public bool Observe(Plate plate, OverlapReportState state)
+    {
+        if (plate == null || !NeedsCheck(plate, state))
+        {
+            pending = null;
+            return false;
+        }
+        if (pending != null && pending.Matches(plate))
+            return false;
+        pending = OverlapGeometryStamp.Capture(plate);
+        return true;
+    }
+
+    /// <summary>
+    /// Call when the quiet period ends. <see cref="OverlapAutoCheckStep.Wait"/> means restart the
+    /// timer (the layout moved or an interaction is still running); only
+    /// <see cref="OverlapAutoCheckStep.Check"/> starts a request.
+    /// </summary>
+    public OverlapAutoCheckStep Elapsed(Plate plate, OverlapReportState state, bool interactionActive)
+    {
+        if (pending == null)
+            return OverlapAutoCheckStep.None;
+        if (plate == null || !NeedsCheck(plate, state))
+        {
+            pending = null;
+            return OverlapAutoCheckStep.None;
+        }
+        if (interactionActive || !pending.Matches(plate))
+        {
+            pending = OverlapGeometryStamp.Capture(plate);
+            return OverlapAutoCheckStep.Wait;
+        }
+        pending = null;
+        return OverlapAutoCheckStep.Check;
+    }
+
+    /// <summary>Record every request start, manual or automatic.</summary>
+    public void Started(Plate plate)
+    {
+        pending = null;
+        lastRequest = OverlapGeometryStamp.Capture(plate);
+    }
+
+    /// <summary>Forget pending and previous requests (plate switch, handle loss, disable).</summary>
+    public void Reset()
+    {
+        pending = null;
+        lastRequest = null;
+    }
+
+    private bool NeedsCheck(Plate plate, OverlapReportState state) => state.Status switch
+    {
+        OverlapCheckStatus.NotChecked or OverlapCheckStatus.Stale => true,
+        OverlapCheckStatus.Canceled or OverlapCheckStatus.Failed => lastRequest?.Matches(plate) != true,
+        _ => false
+    };
+}

OpenNest.Core/Diagnostics/OverlapGeometryStamp.cs

@@ -0,0 +1,66 @@
+using System;
+using OpenNest.CNC;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>
+/// Cheap ordered identity/pose check, not a geometry hash. In-place geometry editors must
+/// explicitly invalidate before mutating. Capture and match only on the model's UI thread.
+/// </summary>
+public sealed class OverlapGeometryStamp
+{
+    private readonly Plate plate;
+    private readonly Entry[] entries;
+
+    private OverlapGeometryStamp(Plate plate)
+    {
+        this.plate = plate;
+        entries = new Entry[plate.Parts.Count];
+        for (var i = 0; i < entries.Length; i++)
+            entries[i] = new Entry(plate.Parts[i]);
+    }
+
+    public static OverlapGeometryStamp Capture(Plate plate) => new(plate);
+
+    public bool Matches(Plate current)
+    {
+        if (!ReferenceEquals(plate, current) || current.Parts.Count != entries.Length)
+            return false;
+        for (var i = 0; i < entries.Length; i++)
+            if (!entries[i].Matches(current.Parts[i]))
+                return false;
+        return true;
+    }
+
+    private readonly struct Entry
+    {
+        private readonly Part part;
+        private readonly Drawing drawing;
+        private readonly Program placedProgram;
+        private readonly Program cleanProgram;
+        private readonly long x, y, rotation;
+        private readonly bool isCutOff;
+
+        public Entry(Part part)
+        {
+            this.part = part;
+            drawing = part.BaseDrawing;
+            placedProgram = part.Program;
+            cleanProgram = drawing.Program;
+            x = BitConverter.DoubleToInt64Bits(part.Location.X);
+            y = BitConverter.DoubleToInt64Bits(part.Location.Y);
+            rotation = BitConverter.DoubleToInt64Bits(part.Rotation);
+            isCutOff = drawing.IsCutOff;
+        }
+
+        public bool Matches(Part current) =>
+            ReferenceEquals(part, current)
+            && ReferenceEquals(drawing, current.BaseDrawing)
+            && ReferenceEquals(placedProgram, current.Program)
+            && ReferenceEquals(cleanProgram, current.BaseDrawing.Program)
+            && x == BitConverter.DoubleToInt64Bits(current.Location.X)
+            && y == BitConverter.DoubleToInt64Bits(current.Location.Y)
+            && rotation == BitConverter.DoubleToInt64Bits(current.Rotation)
+            && isCutOff == current.BaseDrawing.IsCutOff;
+    }
+}

OpenNest.Core/Diagnostics/OverlapHoverPages.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>
+/// Viewport-sized pages of cached overlap details, including continuation pages for a
+/// single long pair. The caller supplies its actual single-line font measurement.
+/// No names or numeric details are elided, and no geometry is queried here.
+/// </summary>
+public sealed class OverlapHoverPages
+{
+    private readonly IReadOnlyList<string>[] pages;
+    private readonly IReadOnlyList<string>[] navigation;
+
+    private OverlapHoverPages(IReadOnlyList<string>[] pages, IReadOnlyList<string>[] navigation,
+        bool needsLargerViewport = false)
+    {
+        this.pages = pages;
+        this.navigation = navigation;
+        NeedsLargerViewport = needsLargerViewport;
+    }
+
+    public IReadOnlyList<string> Lines => PageCount == 0 ? Array.Empty<string>() : pages[PageIndex];
+    public IReadOnlyList<string> NavigationLines => PageCount == 0 ? Array.Empty<string>() : navigation[PageIndex];
+    public int PageIndex { get; private set; }
+    public int PageCount => pages.Length;
+    public bool NeedsLargerViewport { get; }
+
+    public void MovePage(int delta) => PageIndex = (int)System.Math.Clamp((long)PageIndex + delta, 0,
+        System.Math.Max(0, PageCount - 1));
+
+    public static OverlapHoverPages Create(string text, int pairCount, int maxRows,
+        double maxWidth, Func<string, double> measure)
+    {
+        var tooSmall = new OverlapHoverPages([], [], true);
+        if (maxRows < 1 || !double.IsFinite(maxWidth) || maxWidth <= 0)
+            return tooSmall;
+        var lines = Wrap(text, maxWidth, measure);
+        if (lines == null)
+            return tooSmall;
+        if (lines.Count <= maxRows)
+            return new OverlapHoverPages([lines.AsReadOnly()], [Array.Empty<string>()]);
+
+        // Reserve the real, wrapped hint as well as content. Increasing the reserved
+        // rows can increase the page count/digit count, so converge before slicing.
+        for (var hintRows = 2; hintRows < maxRows;)
+        {
+            var contentRows = maxRows - hintRows;
+            var count = (lines.Count - 1) / contentRows + 1;
+            var hints = new IReadOnlyList<string>[count];
+            var requiredHintRows = hintRows;
+            for (var page = 0; page < count; page++)
+            {
+                var hint = Wrap($"Page {page + 1}/{count} · {pairCount} pairs\nPgUp/PgDn", maxWidth, measure);
+                if (hint == null)
+                    return tooSmall;
+                hints[page] = hint.AsReadOnly();
+                requiredHintRows = System.Math.Max(requiredHintRows, hint.Count);
+            }
+            if (requiredHintRows > hintRows)
+            {
+                hintRows = requiredHintRows;
+                continue;
+            }
+            var pages = Enumerable.Range(0, count)
+                .Select(page => (IReadOnlyList<string>)Array.AsReadOnly(lines.Skip(page * contentRows).Take(contentRows).ToArray()))
+                .ToArray();
+            return new OverlapHoverPages(pages, hints);
+        }
+        // There must be room for at least one complete content line AND navigation.
+        return tooSmall;
+    }
+
+    private static List<string> Wrap(string text, double width, Func<string, double> measure)
+    {
+        var lines = new List<string>();
+        foreach (var paragraph in text.Replace("\r\n", "\n").Split('\n'))
+        {
+            if (paragraph.Length == 0)
+            {
+                lines.Add("");
+                continue;
+            }
+            var starts = StringInfo.ParseCombiningCharacters(paragraph).Append(paragraph.Length).ToArray();
+            for (var first = 0; first < starts.Length - 1;)
+            {
+                var low = first;
+                var high = starts.Length - 1;
+                while (low < high)
+                {
+                    var end = low + (high - low + 1) / 2;
+                    if (measure(paragraph[starts[first]..starts[end]]) <= width)
+                        low = end;
+                    else
+                        high = end - 1;
+                }
+                if (low == first)
+                    return null; // Even one grapheme cannot fit; do not silently clip it.
+                var last = low;
+                if (last < starts.Length - 1)
+                {
+                    for (var end = last; end > first; end--)
+                    {
+                        if (char.IsWhiteSpace(paragraph[starts[end - 1]]))
+                        {
+                            last = end;
+                            break;
+                        }
+                    }
+                }
+                lines.Add(paragraph[starts[first]..starts[last]]);
+                first = last;
+            }
+        }
+        return lines;
+    }
+}

OpenNest.Core/Diagnostics/OverlapMaterial.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>Request-local, validated single-outer material. Never exposed to report consumers.</summary>
+internal sealed record OverlapMaterial(Polygon Outer, List<Polygon> Holes)
+{
+    internal static OverlapMaterial Read(List<Entity> entities, CancellationToken cancellationToken)
+    {
+        // ShapeBuilder can reverse entities while chaining. Own a fresh copy for each analysis.
+        var shapes = ShapeBuilder.GetShapes(entities.Select(entity => entity.Clone()));
+        if (shapes.Count == 0)
+            throw new ArgumentException("Drawing has no closed material contour.");
+        var polygons = new List<Polygon>();
+        foreach (var shape in shapes)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            ValidateChain(shape);
+            var polygon = shape.ToPolygonWithTolerance(PlateOverlapAnalyzer.ChordTolerance);
+            // The analytic chain was validated above. Normalize its sampled seam (e.g.
+            // sin(2*pi) is not exactly zero), rather than adding a spurious microscopic edge.
+            if (polygon.IsClosed())
+                polygon.Vertices[^1] = polygon.Vertices[0];
+            ValidatePolygon(polygon, cancellationToken);
+            polygons.Add(polygon);
+        }
+        // Sampling can hide a crossing or tangency between curves. Reject native
+        // contour contact before asking the polygon approximation about containment.
+        for (var i = 0; i < shapes.Count; i++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            for (var j = 0; j < i; j++)
+            {
+                shapes[i].Intersects(shapes[j], out var intersections);
+                if (intersections.Count > 0)
+                    throw new ArgumentException("Native material contours cross or touch.");
+            }
+        }
+        var ordered = polygons.OrderByDescending(polygon => Area(polygon.Vertices)).ToList();
+        var outer = ordered[0];
+        var holes = ordered.Skip(1).ToList();
+        for (var i = 0; i < holes.Count; i++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (BoundariesTouch(outer, holes[i], cancellationToken)
+                || !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++)
+            {
+                if (BoundariesTouch(holes[i], holes[j], cancellationToken)
+                    || Inside(holes[i], holes[j].Vertices[0])
+                    || Inside(holes[j], holes[i].Vertices[0]))
+                    throw new ArgumentException("Intersecting holes and nested material islands are unsupported.");
+            }
+        }
+        return new OverlapMaterial(outer, holes);
+    }
+
+    internal OverlapMaterial Transform(double rotation, Vector offset) =>
+        new(TransformPolygon(Outer, rotation, offset),
+            Holes.Select(hole => TransformPolygon(hole, rotation, offset)).ToList());
+
+    private static Polygon TransformPolygon(Polygon polygon, double rotation, Vector offset)
+    {
+        var transformed = new Polygon();
+        transformed.Vertices.AddRange(polygon.Vertices.Select(point =>
+            (rotation == 0 ? point : point.Rotate(rotation)) + offset));
+        if (transformed.Vertices.Any(point => !IsFinite(point)))
+            throw new ArithmeticException("Transformed contour has nonfinite coordinates.");
+        transformed.UpdateBounds();
+        if (!double.IsFinite(transformed.BoundingBox.Length)
+            || !double.IsFinite(transformed.BoundingBox.Width))
+            throw new ArithmeticException("Transformed contour bounds overflowed.");
+        var sourceArea = Area(polygon.Vertices);
+        var transformedArea = Area(transformed.Vertices);
+        if (!double.IsFinite(transformedArea) || transformedArea <= Tolerance.Epsilon
+            || System.Math.Abs(sourceArea - transformedArea)
+                > System.Math.Max(Tolerance.Epsilon, sourceArea * 1e-8))
+            throw new ArithmeticException("Coordinate precision cannot preserve the contour area at this pose.");
+        for (var i = 0; i + 1 < transformed.Vertices.Count; i++)
+        {
+            var a = transformed.Vertices[i];
+            var b = transformed.Vertices[i + 1];
+            if (a.X == b.X && a.Y == b.Y)
+                throw new ArithmeticException("Coordinate precision collapsed a contour edge at this pose.");
+        }
+        return transformed;
+    }
+
+    internal static bool IsFinite(Vector point) => double.IsFinite(point.X) && double.IsFinite(point.Y);
+
+    /// <summary>Translation-stable unsigned shoelace area; accepts an explicit closing vertex.</summary>
+    internal static double Area(IReadOnlyList<Vector> vertices)
+    {
+        var twiceArea = 0.0;
+        for (var i = 1; i + 1 < vertices.Count; i++)
+            twiceArea += Cross(vertices[0], vertices[i], vertices[i + 1]);
+        return System.Math.Abs(twiceArea) * 0.5;
+    }
+
+    private static void ValidateChain(Shape shape)
+    {
+        if (!shape.IsClosed())
+            throw new ArgumentException("Material contour is open.");
+        foreach (var entity in shape.Entities)
+        {
+            if (!double.IsFinite(entity.Length) || entity.Length <= 0)
+                throw new ArgumentException("Material contour has a nonfinite or zero-length edge.");
+        }
+        if (shape.Entities.Count == 1 && shape.Entities[0] is Circle circle)
+        {
+            if (!IsFinite(circle.Center) || !double.IsFinite(circle.Radius) || circle.Radius <= 0)
+                throw new ArgumentException("Material circle is invalid.");
+            return;
+        }
+        for (var i = 0; i < shape.Entities.Count; i++)
+        {
+            var end = Endpoints(shape.Entities[i]).End;
+            var start = Endpoints(shape.Entities[(i + 1) % shape.Entities.Count]).Start;
+            // Do not let ShapeBuilder's larger chain tolerance silently repair a broken cut.
+            if (!IsFinite(start) || !IsFinite(end) || end.DistanceTo(start) > Tolerance.Epsilon)
+                throw new ArgumentException("Material contour has a gap or invalid endpoint.");
+        }
+    }
+
+    private static (Vector Start, Vector End) Endpoints(Entity entity) => entity switch
+    {
+        Line line => (line.StartPoint, line.EndPoint),
+        Arc arc => (arc.StartPoint(), arc.EndPoint()),
+        _ => throw new ArgumentException("Unsupported material entity."),
+    };
+
+    private static void ValidatePolygon(Polygon polygon, CancellationToken cancellationToken)
+    {
+        var vertices = polygon.Vertices;
+        var area = Area(vertices);
+        if (vertices.Count < 4 || vertices.Any(point => !IsFinite(point))
+            || !double.IsFinite(area) || area <= Tolerance.Epsilon)
+            throw new ArgumentException("Material contour is degenerate or nonfinite.");
+        var count = vertices.Count - 1;
+        for (var i = 0; i < count; i++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var previous = vertices[(i + count - 1) % count];
+            var current = vertices[i];
+            var next = vertices[i + 1];
+            if (current.X == next.X && current.Y == next.Y)
+                throw new ArgumentException("Material polygon has a zero-length edge.");
+            if (Cross(previous, current, next) == 0
+                && (previous.X - current.X) * (next.X - current.X)
+                    + (previous.Y - current.Y) * (next.Y - current.Y) > 0)
+                throw new ArgumentException("Material polygon has a retraced edge.");
+            for (var j = i + 2; j < count; j++)
+            {
+                if (i == 0 && j == count - 1)
+                    continue;
+                if (SegmentsTouch(vertices[i], vertices[i + 1], vertices[j], vertices[j + 1]))
+                    throw new ArgumentException("Material contour self-intersects or touches itself.");
+            }
+        }
+        // Ear clipping can stop early on unusable geometry. Do not certify that as clear.
+        var local = TransformPolygon(polygon, 0, vertices[0] * -1);
+        var triangulatedArea = Collision.Triangulate(local).Sum(triangle => Area(triangle.Vertices));
+        if (!double.IsFinite(triangulatedArea)
+            || System.Math.Abs(triangulatedArea - area) > System.Math.Max(Tolerance.Epsilon, area * 1e-9))
+            throw new ArgumentException("Material contour could not be completely triangulated.");
+    }
+
+    private static bool BoundariesTouch(Polygon a, Polygon b, CancellationToken cancellationToken)
+    {
+        for (var i = 0; i + 1 < a.Vertices.Count; i++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            for (var j = 0; j + 1 < b.Vertices.Count; j++)
+                if (SegmentsTouch(a.Vertices[i], a.Vertices[i + 1], b.Vertices[j], b.Vertices[j + 1]))
+                    return true;
+        }
+        return false;
+    }
+
+    private static bool SegmentsTouch(Vector a, Vector b, Vector c, Vector d)
+    {
+        var ac = Cross(a, b, c);
+        var ad = Cross(a, b, d);
+        var ca = Cross(c, d, a);
+        var cb = Cross(c, d, b);
+        return ac == 0 && OnSegment(a, b, c) || ad == 0 && OnSegment(a, b, d)
+            || ca == 0 && OnSegment(c, d, a) || cb == 0 && OnSegment(c, d, b)
+            || (ac < 0 && ad > 0 || ac > 0 && ad < 0)
+                && (ca < 0 && cb > 0 || ca > 0 && cb < 0);
+    }
+
+    private static bool OnSegment(Vector a, Vector b, Vector point) =>
+        point.X >= System.Math.Min(a.X, b.X) && point.X <= System.Math.Max(a.X, b.X)
+        && 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.
+    private static bool Inside(Polygon polygon, Vector point)
+    {
+        var winding = 0;
+        for (var i = 0; i + 1 < polygon.Vertices.Count; i++)
+        {
+            var a = polygon.Vertices[i];
+            var b = polygon.Vertices[i + 1];
+            if (a.Y <= point.Y && b.Y > point.Y && Cross(a, b, point) > 0)
+                winding++;
+            else if (a.Y > point.Y && b.Y <= point.Y && Cross(a, b, point) < 0)
+                winding--;
+        }
+        return winding != 0;
+    }
+
+    private static double Cross(Vector a, Vector b, Vector point) =>
+        (b.X - a.X) * (point.Y - a.Y) - (b.Y - a.Y) * (point.X - a.X);
+}

OpenNest.Core/Diagnostics/OverlapMaterialCache.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>
+/// Reuses each clean drawing program's converted entities and prepared (validated, chorded,
+/// triangulation-checked) material across overlap requests. Preparation dominates the cost of
+/// drawings with many holes, and it depends only on the drawing, not on where parts sit, so a
+/// recheck after moving parts only repeats the cheap pose transforms and pair clipping.
+/// Entries are keyed by <see cref="Program"/> reference and released with it. A changed code
+/// count or program rotation is detected, but that is not a geometry hash: call
+/// <see cref="Clear"/> before any in-place edit of a clean program or its hole subprograms.
+/// Capture on one thread at a time; prepared entries may be shared by concurrent analyses.
+/// </summary>
+public sealed class OverlapMaterialCache
+{
+    private readonly ConditionalWeakTable<Program, OverlapSource> sources = new();
+
+    public void Clear() => sources.Clear();
+
+    internal OverlapSource Get(Program program, Func<Program, OverlapSource> create)
+    {
+        if (sources.TryGetValue(program, out var source) && source.Matches(program))
+            return source;
+        source = create(program);
+        sources.AddOrUpdate(program, source);
+        return source;
+    }
+}
+
+/// <summary>Owned converted entities for one clean program, plus its lazily prepared material.</summary>
+internal sealed class OverlapSource
+{
+    private readonly object gate = new();
+    private readonly int codeCount;
+    private readonly long rotation;
+    private PreparedMaterial prepared;
+
+    internal OverlapSource(Program program, List<Entity> entities, string error)
+    {
+        codeCount = program.Codes.Count;
+        rotation = BitConverter.DoubleToInt64Bits(program.Rotation);
+        Entities = entities;
+        Error = error;
+    }
+
+    /// <summary>Never mutated; preparation clones before chaining.</summary>
+    internal List<Entity> Entities { get; }
+    internal string Error { get; }
+
+    internal bool Matches(Program program) =>
+        program.Codes.Count == codeCount && BitConverter.DoubleToInt64Bits(program.Rotation) == rotation;
+
+    /// <summary>
+    /// Prepares once and shares the result. A geometry failure is cached like a success;
+    /// cancellation is not, so a superseded request cannot poison the next one.
+    /// </summary>
+    internal PreparedMaterial Prepare(CancellationToken cancellationToken)
+    {
+        var current = Volatile.Read(ref prepared);
+        if (current != null)
+            return current;
+        lock (gate)
+        {
+            if (prepared != null)
+                return prepared;
+            PreparedMaterial result;
+            try
+            {
+                result = new PreparedMaterial(OverlapMaterial.Read(Entities, cancellationToken), null);
+            }
+            catch (Exception exception) when (PlateOverlapAnalyzer.IsGeometryFailure(exception))
+            {
+                result = new PreparedMaterial(null, exception.Message);
+            }
+            Volatile.Write(ref prepared, result);
+            return result;
+        }
+    }
+}
+
+/// <summary>Validated local-frame material, only ever read (transformed into new polygons).</summary>
+internal sealed record PreparedMaterial(OverlapMaterial Material, string Error);

OpenNest.Core/Diagnostics/OverlapPairPresentation.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using OpenNest.Geometry;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>Read-only pair presentation; no geometry preparation or collision queries.</summary>
+public static class OverlapPairPresentation
+{
+    public static string Label(PlateOverlapPair pair) => $"{pair.PartAId + 1}/{pair.PartBId + 1}";
+
+    public static string Details(PlateOverlapPair pair, Units capturedUnits, IFormatProvider provider = null)
+    {
+        var units = UnitsHelper.GetShortString(capturedUnits);
+        return $"Pair {Label(pair)}: {pair.PartAName} / {pair.PartBName}\n"
+            + $"Shared area ≈ {Number(pair.Area, provider)} {units}²\n"
+            + $"Centroid: ({Number(pair.Centroid.X, provider)}, {Number(pair.Centroid.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);
+
+    public static double MarkerHalfSize(int deviceDpi) => 6.0 * deviceDpi / 96;
+    public static double HitRadius(int deviceDpi) => 10.0 * deviceDpi / 96;
+
+    /// <summary>
+    /// Projects cached centroids into a screen-pixel coordinate space. The pointer must
+    /// use that same space; view zoom never scales the DPI-adjusted hit radius.
+    /// 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)
+    {
+        var radius = HitRadius(deviceDpi);
+        return pairs.Where(pair =>
+        {
+            var center = worldToScreen(pair.Centroid);
+            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

@@ -0,0 +1,111 @@
+using System.Collections.Generic;
+
+namespace OpenNest.Diagnostics;
+
+public enum OverlapDisplayMode { Off, Areas, Centroids, Both }
+public enum OverlapCheckStatus { NotChecked, Checking, Current, Incomplete, Failed, Canceled, Stale }
+
+/// <summary>UI-thread lifecycle policy, independent of workers, GDI and view transforms.</summary>
+public sealed class OverlapReportState
+{
+    private OverlapGeometryStamp stamp;
+    private int uncheckedPartCount;
+
+    public long Generation { get; private set; }
+    public OverlapCheckStatus Status { get; private set; } = OverlapCheckStatus.NotChecked;
+    public OverlapDisplayMode DisplayMode { get; set; } = OverlapDisplayMode.Areas;
+    public PlateOverlapReport Report { get; private set; }
+    public bool IsRunning => Status == OverlapCheckStatus.Checking;
+
+    public string Message => Status switch
+    {
+        OverlapCheckStatus.Checking => "Checking overlaps…",
+        OverlapCheckStatus.Current => Report.Pairs.Count == 0
+            ? "No material overlaps detected" : $"Overlaps: {Report.Pairs.Count} pairs",
+        OverlapCheckStatus.Incomplete => $"Overlap check incomplete: {Report.Pairs.Count} overlapping pairs; "
+            + $"{uncheckedPartCount} parts could not be checked",
+        OverlapCheckStatus.Failed => "Overlap check failed — run Check Overlaps again",
+        OverlapCheckStatus.Canceled => "Overlap check canceled",
+        OverlapCheckStatus.Stale => "Overlap check out of date — run Check Overlaps again",
+        _ => "Overlaps: not checked"
+    };
+
+    /// <summary>
+    /// Starts a request. A manual check from Off shows Areas; an automatic recheck keeps
+    /// the user's display choice, including Off.
+    /// </summary>
+    public long Begin(Plate plate, bool automatic = false)
+    {
+        Clear(OverlapCheckStatus.Checking);
+        stamp = OverlapGeometryStamp.Capture(plate);
+        if (!automatic && DisplayMode == OverlapDisplayMode.Off)
+            DisplayMode = OverlapDisplayMode.Areas;
+        return Generation;
+    }
+
+    public bool TryPublish(long generation, Plate plate, PlateOverlapReport report)
+    {
+        if (!CanComplete(generation, plate))
+            return false;
+        Report = report;
+        uncheckedPartCount = CountUncheckedParts(report.Issues);
+        Status = report.IsComplete ? OverlapCheckStatus.Current : OverlapCheckStatus.Incomplete;
+        return true;
+    }
+
+    public bool TryFail(long generation, Plate plate)
+    {
+        if (!CanComplete(generation, plate))
+            return false;
+        Clear(OverlapCheckStatus.Failed);
+        return true;
+    }
+
+    private bool CanComplete(long generation, Plate plate) =>
+        generation == Generation && IsRunning && EnsureFresh(plate);
+
+    public bool EnsureFresh(Plate plate)
+    {
+        if (stamp == null)
+            return false;
+        if (stamp.Matches(plate))
+            return true;
+        Invalidate();
+        return false;
+    }
+
+    public void Invalidate()
+    {
+        if (Status is OverlapCheckStatus.Checking or OverlapCheckStatus.Current or OverlapCheckStatus.Incomplete)
+            Clear(OverlapCheckStatus.Stale);
+    }
+
+    public void Cancel()
+    {
+        if (IsRunning)
+            Clear(OverlapCheckStatus.Canceled);
+    }
+
+    public void Reset() => Clear(OverlapCheckStatus.NotChecked);
+
+    private void Clear(OverlapCheckStatus status)
+    {
+        Generation++;
+        Report = null;
+        uncheckedPartCount = 0;
+        stamp = null;
+        Status = status;
+    }
+
+    public static int CountUncheckedParts(IEnumerable<PlateOverlapIssue> issues)
+    {
+        var ids = new HashSet<int>();
+        foreach (var issue in issues)
+        {
+            ids.Add(issue.PartAId);
+            if (issue.PartBId.HasValue)
+                ids.Add(issue.PartBId.Value);
+        }
+        return ids.Count;
+    }
+}

OpenNest.Core/Diagnostics/PlateOverlapAnalyzer.cs

@@ -0,0 +1,292 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using OpenNest.CNC;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>
+/// Read-only, hole-aware material overlap diagnostics, separate from the engine's boolean checks.
+/// Uses clean drawing outlines, not placed lead-in/tab toolpaths or spacing offsets.
+/// </summary>
+public static class PlateOverlapAnalyzer
+{
+    public const double ChordTolerance = 0.001;
+
+    /// <summary>
+    /// Captures poses and converts each distinct clean source program to owned entities once.
+    /// Inputs must not change during capture. Later analysis never reads live domain objects.
+    /// </summary>
+    public static PlateOverlapSnapshot Capture(IReadOnlyList<Part> parts,
+        CancellationToken cancellationToken = default) =>
+        Capture(parts, new OverlapMaterialCache(), cancellationToken);
+
+    /// <summary>
+    /// As <see cref="Capture(IReadOnlyList{Part}, CancellationToken)"/>, but reuses converted
+    /// and prepared drawing material from <paramref name="cache"/> across requests. Clear the
+    /// cache before any in-place clean-program edit (see <see cref="OverlapMaterialCache"/>).
+    /// </summary>
+    public static PlateOverlapSnapshot Capture(IReadOnlyList<Part> parts, OverlapMaterialCache cache,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(parts);
+        ArgumentNullException.ThrowIfNull(cache);
+        cancellationToken.ThrowIfCancellationRequested();
+        var captured = new List<CapturedOverlapPart>();
+        var issues = new List<PlateOverlapIssue>();
+        for (var id = 0; id < parts.Count; id++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var part = parts[id];
+            if (part?.BaseDrawing?.IsCutOff == true)
+                continue;
+            try
+            {
+                if (part?.BaseDrawing?.Program == null)
+                    throw new ArgumentException("Part has no clean drawing program.");
+                var program = part.BaseDrawing.Program;
+                var rotation = part.Rotation - program.Rotation;
+                var location = part.Location;
+                if (!double.IsFinite(rotation) || !OverlapMaterial.IsFinite(location))
+                    throw new ArgumentException("Part pose must be finite.");
+                var source = cache.Get(program, CaptureSource);
+                if (source.Error != null)
+                    throw new ArgumentException(source.Error);
+                captured.Add(new CapturedOverlapPart(id, part.BaseDrawing.Name,
+                    source, rotation, location));
+            }
+            catch (Exception exception) when (IsGeometryFailure(exception))
+            {
+                issues.Add(new PlateOverlapIssue(id, null, exception.Message));
+            }
+        }
+        cancellationToken.ThrowIfCancellationRequested();
+        return new PlateOverlapSnapshot(captured, issues);
+    }
+
+    private static OverlapSource CaptureSource(Program program)
+    {
+        try
+        {
+            ValidateProgram(program, new HashSet<Program>(ReferenceEqualityComparer.Instance));
+            // Conversion creates fresh geometry, including expanded shared hole calls;
+            // no cloning/rotation of a live program or subprogram is necessary.
+            return new OverlapSource(program, ConvertProgram.ToGeometry(program)
+                .Where(entity => SpecialLayers.IsMaterial(entity.Layer)
+                    && entity.Layer != SpecialLayers.Leadin
+                    && entity.Layer != SpecialLayers.Leadout).ToList(), null);
+        }
+        catch (Exception exception) when (IsGeometryFailure(exception))
+        {
+            return new OverlapSource(program, null, exception.Message);
+        }
+    }
+
+    /// <summary>Convenience synchronous capture and analysis of a group of parts.</summary>
+    public static PlateOverlapReport Analyze(IReadOnlyList<Part> parts,
+        CancellationToken cancellationToken = default) =>
+        Analyze(Capture(parts, cancellationToken), cancellationToken);
+
+    /// <summary>
+    /// Returns deterministic pair reports containing closed world-coordinate overlap fragments.
+    /// Cancellation throws and publishes no partial report. Check IsComplete before claiming clear.
+    /// </summary>
+    public static PlateOverlapReport Analyze(PlateOverlapSnapshot snapshot,
+        CancellationToken cancellationToken = default) =>
+        Analyze(snapshot, null, cancellationToken);
+
+    /// <summary>
+    /// Incremental recheck: identical to a full analysis of <paramref name="snapshot"/>, but a
+    /// pair whose two parts are unchanged since <paramref name="previous"/> (same captured source
+    /// and bit-identical pose, in the same relative order) reuses that report's result instead
+    /// of being clipped again. After moving one part only its own neighbors are recomputed.
+    /// Reuse needs sources shared through one <see cref="OverlapMaterialCache"/>; otherwise every
+    /// pair is recomputed. Null <paramref name="previous"/> performs a full analysis.
+    /// </summary>
+    public static PlateOverlapReport Analyze(PlateOverlapSnapshot snapshot, PlateOverlapReport previous,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(snapshot);
+        cancellationToken.ThrowIfCancellationRequested();
+        var reuse = PairReuse.Create(previous, snapshot);
+        var issues = snapshot.Issues.ToList();
+        var pairs = new List<PlateOverlapPair>();
+        var prepared = new List<PreparedPart>();
+        foreach (var part in snapshot.Parts)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            try
+            {
+                // Prepared material is shared by every part and request using this source.
+                var source = part.Source.Prepare(cancellationToken);
+                if (source.Error != null)
+                    throw new ArgumentException(source.Error);
+                var material = source.Material.Transform(part.Rotation, part.Location);
+                prepared.Add(new PreparedPart(part, material));
+            }
+            catch (Exception exception) when (IsGeometryFailure(exception))
+            {
+                issues.Add(new PlateOverlapIssue(part.Id, null, exception.Message));
+            }
+        }
+
+        var sorted = prepared.OrderBy(part => part.Material.Outer.BoundingBox.Left)
+            .ThenBy(part => part.Input.Id).ToArray();
+        for (var i = 0; i < sorted.Length; i++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var first = sorted[i];
+            var bounds = first.Material.Outer.BoundingBox;
+            for (var j = i + 1; j < sorted.Length; j++)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var second = sorted[j];
+                var otherBounds = second.Material.Outer.BoundingBox;
+                if (otherBounds.Left >= bounds.Right)
+                    break;
+                if (otherBounds.Bottom >= bounds.Top || bounds.Bottom >= otherBounds.Top)
+                    continue;
+                var a = first.Input.Id < second.Input.Id ? first : second;
+                var b = first.Input.Id < second.Input.Id ? second : first;
+                if (reuse != null && reuse.TryReuse(a.Input, b.Input, pairs, issues))
+                    continue;
+                try
+                {
+                    // Keep pair clipping arithmetic near the parts where possible, then
+                    // restore output to world space. Triangulation itself also uses stable
+                    // local-origin winding so tiny holes in a huge part remain correct.
+                    var origin = a.Material.Outer.Vertices[0];
+                    var localA = a.Material.Transform(0, origin * -1);
+                    var localB = b.Material.Transform(0, origin * -1);
+                    var result = Collision.Check(localA.Outer, localB.Outer, localA.Holes, localB.Holes);
+                    if (!result.Overlaps)
+                        continue;
+                    // Evaluate every hole-subtracted fragment before restoring world space.
+                    // A failed moment must make this pair incomplete, never an origin marker.
+                    var moments = new List<PolygonAreaMoments>();
+                    var regions = new List<PlateOverlapRegion>();
+                    foreach (var region in result.OverlapRegions)
+                    {
+                        cancellationToken.ThrowIfCancellationRequested();
+                        if (!PolygonAreaMoments.TryCompute(region.Vertices, out var fragment))
+                            throw new ArithmeticException("Overlap fragment area moments are invalid.");
+                        moments.Add(fragment);
+                        regions.Add(new PlateOverlapRegion(region.Vertices.Select(point => point + origin),
+                            fragment.Area));
+                    }
+                    if (!PolygonAreaMoments.TryCombine(moments, out var combined))
+                        throw new ArithmeticException("Combined overlap area moments are invalid.");
+                    var centroid = combined.Centroid + origin;
+                    if (!OverlapMaterial.IsFinite(centroid))
+                        throw new ArithmeticException("Overlap centroid is not finite in world coordinates.");
+                    pairs.Add(new PlateOverlapPair(a.Input.Id, b.Input.Id,
+                        a.Input.Name, b.Input.Name, regions, centroid));
+                }
+                catch (Exception exception) when (IsGeometryFailure(exception))
+                {
+                    issues.Add(new PlateOverlapIssue(a.Input.Id, b.Input.Id, exception.Message));
+                }
+            }
+        }
+        cancellationToken.ThrowIfCancellationRequested();
+        return new PlateOverlapReport(pairs.OrderBy(pair => pair.PartAId)
+            .ThenBy(pair => pair.PartBId).ToList(), issues.OrderBy(issue => issue.PartAId)
+            .ThenBy(issue => issue.PartBId).ToList(), snapshot);
+    }
+
+    /// <summary>
+    /// Maps unchanged parts to their previous input positions and looks up previous pair results.
+    /// A part is unchanged when its captured source object and exact pose bits match; identical
+    /// duplicates are matched in input order, which is safe because their inputs are bit-identical.
+    /// </summary>
+    private sealed class PairReuse
+    {
+        private readonly Dictionary<int, int> previousIds;
+        private readonly Dictionary<(int, int), PlateOverlapPair> pairs = new();
+        private readonly Dictionary<(int, int), PlateOverlapIssue> issues = new();
+
+        private PairReuse(Dictionary<int, int> previousIds, PlateOverlapReport previous)
+        {
+            this.previousIds = previousIds;
+            foreach (var pair in previous.Pairs)
+                pairs[(pair.PartAId, pair.PartBId)] = pair;
+            foreach (var issue in previous.Issues)
+                if (issue.PartBId.HasValue)
+                    issues[(issue.PartAId, issue.PartBId.Value)] = issue;
+        }
+
+        public static PairReuse Create(PlateOverlapReport previous, PlateOverlapSnapshot snapshot)
+        {
+            if (previous?.Snapshot == null)
+                return null;
+            var available = new Dictionary<PoseKey, Queue<int>>();
+            foreach (var part in previous.Snapshot.Parts)
+            {
+                var key = PoseKey.Of(part);
+                if (!available.TryGetValue(key, out var ids))
+                    available.Add(key, ids = new Queue<int>());
+                ids.Enqueue(part.Id);
+            }
+            var previousIds = new Dictionary<int, int>();
+            foreach (var part in snapshot.Parts)
+                if (available.TryGetValue(PoseKey.Of(part), out var ids) && ids.Count > 0)
+                    previousIds.Add(part.Id, ids.Dequeue());
+            return previousIds.Count < 2 ? null : new PairReuse(previousIds, previous);
+        }
+
+        /// <summary>
+        /// Every bounding-box candidate pair among prepared parts was evaluated by the previous
+        /// analysis, and unchanged parts have identical bounds, so absence there means clear.
+        /// The previous pair must have had the same operand order: clipping is order-sensitive.
+        /// </summary>
+        public bool TryReuse(CapturedOverlapPart a, CapturedOverlapPart b,
+            List<PlateOverlapPair> pairOutput, List<PlateOverlapIssue> issueOutput)
+        {
+            if (!previousIds.TryGetValue(a.Id, out var oldA) || !previousIds.TryGetValue(b.Id, out var oldB)
+                || oldA >= oldB)
+                return false;
+            if (pairs.TryGetValue((oldA, oldB), out var pair))
+                pairOutput.Add(pair.Renumber(a.Id, b.Id, a.Name, b.Name));
+            else if (issues.TryGetValue((oldA, oldB), out var issue))
+                issueOutput.Add(issue with { PartAId = a.Id, PartBId = b.Id });
+            return true;
+        }
+    }
+
+    private readonly record struct PoseKey(OverlapSource Source, long Rotation, long X, long Y)
+    {
+        public static PoseKey Of(CapturedOverlapPart part) => new(part.Source,
+            BitConverter.DoubleToInt64Bits(part.Rotation),
+            BitConverter.DoubleToInt64Bits(part.Location.X),
+            BitConverter.DoubleToInt64Bits(part.Location.Y));
+    }
+
+    internal static bool IsGeometryFailure(Exception exception) => exception is
+        ArgumentException or InvalidOperationException or NotSupportedException or ArithmeticException;
+
+    private static void ValidateProgram(Program program, HashSet<Program> visiting)
+    {
+        if (program == null || !visiting.Add(program) || visiting.Count > 64)
+            throw new ArgumentException("Missing, recursive, or excessively nested subprogram.");
+        foreach (var code in program.Codes)
+        {
+            if (code == null)
+                throw new ArgumentException("Program contains a missing instruction.");
+            if (code is Motion motion && !OverlapMaterial.IsFinite(motion.EndPoint)
+                || code is ArcMove arc && !OverlapMaterial.IsFinite(arc.CenterPoint))
+                throw new ArgumentException("Program coordinates must be finite.");
+            if (code is SubProgramCall call)
+            {
+                if (!OverlapMaterial.IsFinite(call.Offset) || !double.IsFinite(call.Rotation))
+                    throw new ArgumentException("Subprogram pose must be finite.");
+                ValidateProgram(call.Program, visiting);
+            }
+        }
+        visiting.Remove(program);
+    }
+
+    private sealed record PreparedPart(CapturedOverlapPart Input, OverlapMaterial Material);
+}

OpenNest.Core/Diagnostics/PlateOverlapReport.cs

@@ -0,0 +1,116 @@
+using System.Collections.Generic;
+using System.Linq;
+using OpenNest.Geometry;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>An owned diagnostic result. An empty Pairs list is clear only if IsComplete is true.</summary>
+public sealed class PlateOverlapReport
+{
+    internal PlateOverlapReport(List<PlateOverlapPair> pairs, List<PlateOverlapIssue> issues,
+        PlateOverlapSnapshot snapshot)
+    {
+        Pairs = pairs.AsReadOnly();
+        Issues = issues.AsReadOnly();
+        Snapshot = snapshot;
+    }
+
+    /// <summary>The owned input this report was computed from; the baseline for incremental rechecks.</summary>
+    internal PlateOverlapSnapshot Snapshot { get; }
+
+    public IReadOnlyList<PlateOverlapPair> Pairs { get; }
+    public IReadOnlyList<PlateOverlapIssue> Issues { get; }
+    public bool IsComplete => Issues.Count == 0;
+    public double ChordTolerance => PlateOverlapAnalyzer.ChordTolerance;
+}
+
+/// <summary>Shared material for two input positions, ordered by zero-based input index.</summary>
+public sealed class PlateOverlapPair
+{
+    private readonly Box bounds;
+
+    private PlateOverlapPair(PlateOverlapPair source, int partAId, int partBId, string partAName,
+        string partBName)
+    {
+        PartAId = partAId;
+        PartBId = partBId;
+        PartAName = partAName;
+        PartBName = partBName;
+        Regions = source.Regions;
+        Area = source.Area;
+        Centroid = source.Centroid;
+        bounds = source.bounds;
+    }
+
+    /// <summary>The same immutable geometry under new input positions and captured names.</summary>
+    internal PlateOverlapPair Renumber(int partAId, int partBId, string partAName, string partBName) =>
+        new(this, partAId, partBId, partAName, partBName);
+
+    internal PlateOverlapPair(int partAId, int partBId, string partAName, string partBName,
+        List<PlateOverlapRegion> regions, Vector centroid)
+    {
+        PartAId = partAId;
+        PartBId = partBId;
+        PartAName = partAName;
+        PartBName = partBName;
+        Regions = regions.AsReadOnly();
+        Area = regions.Sum(region => region.Area);
+        Centroid = centroid;
+        var points = regions.SelectMany(region => region.Vertices).ToArray();
+        var left = points.Min(point => point.X);
+        var bottom = points.Min(point => point.Y);
+        bounds = new Box(left, bottom, points.Max(point => point.X) - left,
+            points.Max(point => point.Y) - bottom);
+    }
+
+    public int PartAId { get; }
+    public int PartBId { get; }
+    public string PartAName { get; }
+    public string PartBName { get; }
+    /// <summary>Convex fragments, not connected islands; no mutable kernel polygons are exposed.</summary>
+    public IReadOnlyList<PlateOverlapRegion> Regions { get; }
+    public double Area { get; }
+    /// <summary>
+    /// Finite world-coordinate area centroid of all shared material, after hole subtraction.
+    /// This can lie outside disconnected or concave shared material. Returned by value.
+    /// </summary>
+    public Vector Centroid { get; }
+    /// <summary>A fresh world-coordinate bounds copy.</summary>
+    public Box Bounds => new(bounds.X, bounds.Y, bounds.Length, bounds.Width);
+}
+
+/// <summary>A positive-area, hole-subtracted convex polygon in world coordinates.</summary>
+public sealed class PlateOverlapRegion
+{
+    internal PlateOverlapRegion(IEnumerable<Vector> vertices, double area)
+    {
+        Vertices = System.Array.AsReadOnly(vertices.ToArray());
+        Area = area;
+    }
+
+    /// <summary>Read-only vertices with an exactly repeated closing vertex.</summary>
+    public IReadOnlyList<Vector> Vertices { get; }
+    public double Area { get; }
+}
+
+/// <summary>An input or pair that could not be checked. IDs are zero-based input positions.</summary>
+public sealed record PlateOverlapIssue(int PartAId, int? PartBId, string Message);
+
+/// <summary>
+/// Owned clean geometry and poses. Capture while inputs are stable, then analyze on a worker.
+/// No live Part, Drawing, Program, or subprogram is retained.
+/// </summary>
+public sealed class PlateOverlapSnapshot
+{
+    internal PlateOverlapSnapshot(List<CapturedOverlapPart> parts, List<PlateOverlapIssue> issues)
+    {
+        Parts = parts.AsReadOnly();
+        Issues = issues.AsReadOnly();
+    }
+
+    internal IReadOnlyList<CapturedOverlapPart> Parts { get; }
+    internal IReadOnlyList<PlateOverlapIssue> Issues { get; }
+}
+
+internal sealed record CapturedOverlapPart(int Id, string Name, OverlapSource Source,
+    double Rotation, Vector Location);

OpenNest.Core/Diagnostics/PostVerificationAnalyzer.cs

@@ -0,0 +1,290 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>
+/// Read-only pre-post diagnostics. The caller must keep the nest stable for the entire call.
+/// Placed programs are already rotated; only their placement translation is applied here.
+/// This intentionally does not invoke a post or promise machine collision avoidance.
+/// </summary>
+public static class PostVerificationAnalyzer
+{
+    public static PostVerificationReport AnalyzeForPost(Nest nest, IPostProcessor postProcessor,
+        CancellationToken cancellationToken = default)
+    {
+        var report = Analyze(nest, cancellationToken);
+        if (postProcessor is IPostVerificationSupport { PreservesPlacedProgramOrder: true })
+            return report;
+        var findings = report.Findings.ToList();
+        findings.Add(new(PostVerificationKind.Incomplete, 0, null, null,
+            $"Post '{postProcessor?.Name ?? "unknown"}' does not declare that it preserves placed part/contour order " +
+            "and pierce positions. Nest-level checks ran, but the final rapid sequence requires manual review."));
+        return new PostVerificationReport(findings);
+    }
+
+    public static PostVerificationReport Analyze(Nest nest, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(nest);
+        cancellationToken.ThrowIfCancellationRequested();
+        var findings = new List<PostVerificationFinding>();
+        if (nest.Plates == null)
+        {
+            findings.Add(new(PostVerificationKind.Incomplete, 1, null, null, "Nest has no plate collection."));
+            return new PostVerificationReport(findings);
+        }
+        for (var plateIndex = 0; plateIndex < nest.Plates.Count; plateIndex++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var plate = nest.Plates[plateIndex];
+            var plateNumber = plateIndex + 1;
+            if (plate?.Parts == null)
+            {
+                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, null, null,
+                    "Plate has no part collection."));
+                continue;
+            }
+            var materialParts = new List<Part>();
+            var indices = new List<int>();
+            var obstacles = new List<Obstacle>();
+            Vector? position = Vector.Zero;
+            for (var index = 0; index < plate.Parts.Count; index++)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var part = plate.Parts[index];
+                var partNumber = index + 1;
+                var cutoff = part?.BaseDrawing?.IsCutOff == true;
+                var expectsCuts = cutoff;
+                // Preflight even clean programs before calling the overlap converter: malformed
+                // recursive graphs must never reach Program.Clone or unguarded conversion.
+                if (!cutoff)
+                {
+                    try
+                    {
+                        var clean = Read(part?.BaseDrawing?.Program, Vector.Zero, null, cancellationToken);
+                        expectsCuts = clean.Any(move => !move.Rapid && move.Layer != LayerType.Scribe);
+                        if (!clean.Any(move => move.Layer == LayerType.Scribe)
+                            || expectsCuts)
+                        {
+                            materialParts.Add(part);
+                            indices.Add(partNumber);
+                        }
+                    }
+                    catch (Exception exception) when (IsInvalid(exception))
+                    {
+                        Incomplete("Overlap check: " + exception.Message);
+                    }
+                }
+                try
+                {
+                    if (part == null || !double.IsFinite(part.Rotation))
+                        throw new ArgumentException("Missing part or invalid rotation.");
+                    var moves = Read(part.Program, part.Location, position, cancellationToken);
+                    if (expectsCuts && !moves.Any(move => !move.Rapid
+                        && move.Layer is LayerType.Cut or LayerType.Display
+                        && move.Curve.Length > PostVerificationGeometry.Epsilon))
+                        Incomplete("Placed program has no cutting contour motions for this drawing.");
+                    AnalyzeMoves(moves, cutoff, obstacles, findings, plateNumber, partNumber, cancellationToken);
+                    position = moves[^1].End;
+                }
+                catch (Exception exception) when (IsInvalid(exception))
+                {
+                    Incomplete("Lead-in/rapid check: " + exception.Message);
+                    // Subsequent internal moves can still be checked, but the incoming segment
+                    // cannot be reconstructed after an invalid program.
+                    position = null;
+                }
+
+                void Incomplete(string message) => findings.Add(new(PostVerificationKind.Incomplete,
+                    plateNumber, partNumber, null, message));
+            }
+            cancellationToken.ThrowIfCancellationRequested();
+            var overlap = PlateOverlapAnalyzer.Analyze(
+                PlateOverlapAnalyzer.Capture(materialParts, cancellationToken), cancellationToken);
+            foreach (var pair in overlap.Pairs)
+                findings.Add(new(PostVerificationKind.Overlap, plateNumber, indices[pair.PartAId],
+                    indices[pair.PartBId], "Clean drawing material overlaps (holes subtracted)."));
+            foreach (var issue in overlap.Issues)
+                findings.Add(new(PostVerificationKind.Incomplete, plateNumber, indices[issue.PartAId],
+                    issue.PartBId is { } other ? indices[other] : null, "Overlap check: " + issue.Message));
+        }
+        cancellationToken.ThrowIfCancellationRequested();
+        return new PostVerificationReport(findings);
+    }
+
+    private static bool IsInvalid(Exception exception) => exception is
+        ArgumentException or InvalidOperationException or NotSupportedException or ArithmeticException;
+
+    private static List<Move> Read(Program program, Vector origin, Vector? previous,
+        CancellationToken token)
+    {
+        var moves = new List<Move>();
+        var visiting = new HashSet<Program>(ReferenceEqualityComparer.Instance);
+        var budget = 1000000;
+        Walk(program, origin, previous);
+        return moves;
+
+        Vector Walk(Program current, Vector frame, Vector? arrival)
+        {
+            token.ThrowIfCancellationRequested();
+            PostVerificationGeometry.Validate(frame);
+            if (current?.Codes == null || !visiting.Add(current) || visiting.Count > 64)
+                throw new ArgumentException("Missing, recursive or excessively nested program.");
+            var pos = frame;
+            var first = true;
+            var countBefore = moves.Count;
+            foreach (var code in current.Codes)
+            {
+                token.ThrowIfCancellationRequested();
+                if (--budget < 0)
+                    throw new ArgumentException("Program expansion exceeds the verification limit.");
+                if (code == null)
+                    throw new ArgumentException("Program contains a missing instruction.");
+                if (code is SubProgramCall call)
+                {
+                    if (!double.IsFinite(call.Rotation))
+                        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);
+                    first = false;
+                    continue;
+                }
+                if (code is not Motion motion)
+                {
+                    if (code is not (Comment or Feedrate or Kerf))
+                        throw new NotSupportedException("Unsupported program instruction.");
+                    continue;
+                }
+                // Posts disagree about incremental position after suppressed instructions.
+                // Never silently certify a trajectory whose semantics are ambiguous.
+                if (motion.Suppressed)
+                    throw new NotSupportedException("Suppressed motion requires post-specific verification.");
+                if (motion is not (RapidMove or LinearMove or ArcMove))
+                    throw new NotSupportedException("Unsupported motion.");
+                var reference = current.Mode == Mode.Incremental ? pos : frame;
+                var end = reference + motion.EndPoint;
+                PostVerificationGeometry.Validate(end);
+                var rapid = motion is RapidMove;
+                if (first && !rapid)
+                    moves.Add(new(arrival, frame, true, LayerType.Display, null));
+                var start = first && rapid ? arrival : pos;
+                var layer = motion switch
+                {
+                    LinearMove line => line.Layer,
+                    ArcMove arc => arc.Layer,
+                    _ => LayerType.Display
+                };
+                if (!Enum.IsDefined(layer))
+                    throw new NotSupportedException("Unsupported motion layer.");
+                if (motion is ArcMove direction && !Enum.IsDefined(direction.Rotation))
+                    throw new NotSupportedException("Unsupported arc direction.");
+                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));
+                pos = end;
+                first = false;
+            }
+            visiting.Remove(current);
+            if (moves.Count == countBefore)
+                throw new ArgumentException("Program has no motions.");
+            return pos;
+        }
+    }
+
+    private static void AnalyzeMoves(List<Move> moves, bool cutoff, List<Obstacle> obstacles,
+        List<PostVerificationFinding> findings, int plate, int part, CancellationToken token)
+    {
+        var contour = new List<PostVerificationGeometry.Curve>();
+        var unfinished = new List<PostVerificationGeometry.Curve[]>();
+        var hasLead = false;
+        var contourNumber = 0;
+        foreach (var move in moves)
+        {
+            token.ThrowIfCancellationRequested();
+            if (move.Rapid)
+            {
+                Finish();
+                hasLead = false;
+                if (move.Start is not { } start || start.DistanceTo(move.End) <= PostVerificationGeometry.Epsilon)
+                    continue;
+                foreach (var obstacle in obstacles)
+                {
+                    token.ThrowIfCancellationRequested();
+                    if (PostVerificationGeometry.Crosses(start, move.End, obstacle.Curves, token))
+                        findings.Add(new(PostVerificationKind.RapidCrossing, plate, part, obstacle.Part,
+                            $"Direct XY rapid crosses or touches completed untabbed contour {obstacle.Contour} " +
+                            $"of part {obstacle.Part}."));
+                }
+            }
+            else if (move.Layer == LayerType.Leadin)
+            {
+                Finish();
+                hasLead |= move.Curve.Length > PostVerificationGeometry.Epsilon;
+            }
+            else if (move.Layer is LayerType.Leadout or LayerType.Scribe)
+            {
+                if (move.Layer == LayerType.Leadout && contour.Count > 0
+                    && !PostVerificationGeometry.Closed(contour)
+                    && move.Curve.Length > PostVerificationGeometry.Epsilon)
+                    findings.Add(new(PostVerificationKind.Incomplete, plate, part, null,
+                        "A lead-out follows an open cutting contour and may cut through its retention gap. " +
+                        "Rapid safety for that contour requires manual review."));
+                Finish();
+                hasLead = false;
+            }
+            else if (move.Curve.Length > PostVerificationGeometry.Epsilon)
+            {
+                if (contour.Count == 0)
+                {
+                    contourNumber++;
+                    if (!cutoff && !hasLead)
+                        findings.Add(new(PostVerificationKind.MissingLeadIn, plate, part, null,
+                            $"Cutting contour {contourNumber} has no nonzero placed lead-in motion."));
+                    hasLead = false;
+                    // A rapid can pause/reposition without leaving any material gap.
+                    // Retain already-cut fragments, but do not turn them into obstacles
+                    // until an actually continuous chain closes.
+                    var previous = unfinished.FindIndex(chain =>
+                        chain[^1].End.DistanceTo(move.Curve.Start) <= PostVerificationGeometry.Epsilon);
+                    if (previous >= 0)
+                    {
+                        contour.AddRange(unfinished[previous]);
+                        unfinished.RemoveAt(previous);
+                    }
+                }
+                contour.Add(move.Curve);
+                // A completed contour becomes an obstacle immediately, not at part end.
+                if (PostVerificationGeometry.Closed(contour))
+                    Finish();
+            }
+        }
+        Finish();
+        if (unfinished.Count > 1)
+            findings.Add(new(PostVerificationKind.Incomplete, plate, part, null,
+                "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."));
+
+        void Finish()
+        {
+            if (contour.Count == 0)
+                return;
+            // A real uncut gap leaves the contour attached. CuttingParameters can be stale;
+            // no flag or tab configuration is used as evidence of retention.
+            if (!cutoff && PostVerificationGeometry.Closed(contour))
+                obstacles.Add(new(part, contourNumber, contour.ToArray()));
+            else if (!cutoff)
+                unfinished.Add(contour.ToArray());
+            contour.Clear();
+        }
+    }
+
+    private sealed record Move(Vector? Start, Vector End, bool Rapid, LayerType Layer,
+        PostVerificationGeometry.Curve Curve);
+    private sealed record Obstacle(int Part, int Contour, IReadOnlyList<PostVerificationGeometry.Curve> Curves);
+}

OpenNest.Core/Diagnostics/PostVerificationGeometry.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using OpenNest.Geometry;
+
+namespace OpenNest.Diagnostics;
+
+/// <summary>Local native line/arc queries, without changing the engine's geometry semantics.</summary>
+internal static class PostVerificationGeometry
+{
+    internal const double Epsilon = 1e-8;
+    private const double TwoPi = 2 * System.Math.PI;
+
+    internal static void Validate(Vector point)
+    {
+        if (!double.IsFinite(point.X) || !double.IsFinite(point.Y)
+            || System.Math.Abs(point.X) > 1e12 || System.Math.Abs(point.Y) > 1e12)
+            throw new ArgumentException("Nonfinite or numerically unsupported program coordinates.");
+    }
+
+    internal static bool Closed(IReadOnlyList<Curve> curves) => curves.Count > 0
+        && curves[0].Start.DistanceTo(curves[^1].End) <= Epsilon;
+
+    internal static bool Crosses(Vector start, Vector end, IReadOnlyList<Curve> curves,
+        CancellationToken token)
+    {
+        var delta = end - start;
+        var length = start.DistanceTo(end);
+        if (length <= Epsilon)
+            return false;
+        var direction = delta * (1 / length);
+        foreach (var curve in curves)
+        {
+            token.ThrowIfCancellationRequested();
+            if (curve.ContactAfterStart(start, direction, length))
+                return true;
+        }
+        // If there are no contacts except possibly departure, all open-segment points
+        // have the same inside/outside status. A midpoint catches travel entirely inside
+        // and departure into the interior, without flagging start-only outward contact.
+        var midpoint = start + delta * 0.5;
+        var inside = false;
+        foreach (var curve in curves)
+        {
+            token.ThrowIfCancellationRequested();
+            if (curve.CrossesRay(midpoint))
+                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 double Normalize(double angle)
+    {
+        angle %= TwoPi;
+        return angle < 0 ? angle + TwoPi : angle;
+    }
+
+    internal sealed class Curve
+    {
+        private Curve(Vector start, Vector end, Vector? center, double radius, double sweep)
+        {
+            Start = start;
+            End = end;
+            Center = center;
+            Radius = radius;
+            Sweep = sweep;
+        }
+
+        internal Vector Start { get; }
+        internal Vector End { get; }
+        private Vector? Center { get; }
+        private double Radius { get; }
+        private double Sweep { get; }
+        internal double Length => Center.HasValue ? Radius * System.Math.Abs(Sweep) : Start.DistanceTo(End);
+
+        internal static Curve Create(Vector start, Vector end, Vector? center, bool clockwise)
+        {
+            if (center is not { } c)
+                return new Curve(start, end, null, 0, 0);
+            Validate(c);
+            var radius = start.DistanceTo(c);
+            if (radius <= Epsilon || !double.IsFinite(radius)
+                || System.Math.Abs(radius - end.DistanceTo(c)) > Epsilon * System.Math.Max(1, radius))
+                throw new ArgumentException("Arc has zero or inconsistent radius.");
+            var a = System.Math.Atan2(start.Y - c.Y, start.X - c.X);
+            var b = System.Math.Atan2(end.Y - c.Y, end.X - c.X);
+            var sweep = start.DistanceTo(end) <= Epsilon ? TwoPi
+                : Normalize(clockwise ? a - b : b - a);
+            return new Curve(start, end, c, radius, clockwise ? -sweep : sweep);
+        }
+
+        private double StartAngle => System.Math.Atan2(Start.Y - Center.Value.Y, Start.X - Center.Value.X);
+        private double Travel(double angle) => Normalize(Sweep < 0 ? StartAngle - angle : angle - StartAngle);
+        private bool OnArc(Vector point) => Travel(System.Math.Atan2(point.Y - Center.Value.Y,
+            point.X - Center.Value.X)) <= System.Math.Abs(Sweep) + Epsilon / Radius
+            || point.DistanceTo(Start) <= Epsilon || point.DistanceTo(End) <= Epsilon;
+
+        internal bool ContactAfterStart(Vector origin, Vector direction, double length)
+        {
+            if (Center is { } center)
+            {
+                // Intersect the actual circle, not an inscribed chord polygon: tangencies
+                // and short arcs must not vanish between tessellation vertices.
+                var relative = center - origin;
+                var projection = Dot(relative, direction);
+                var perpendicular = Cross(relative, direction);
+                var square = Radius * Radius - perpendicular * perpendicular;
+                if (square < -Epsilon * System.Math.Max(1, Radius * 2))
+                    return false;
+                var offset = System.Math.Sqrt(System.Math.Max(0, square));
+                return Hit(projection - offset) || Hit(projection + offset);
+
+                bool Hit(double distance) => distance > Epsilon && distance <= length + Epsilon
+                    && OnArc(origin + direction * System.Math.Clamp(distance, 0, length));
+            }
+            var edge = End - Start;
+            var relativeStart = Start - origin;
+            var denominator = Cross(direction, edge);
+            if (System.Math.Abs(denominator) <= 1e-12 * System.Math.Max(1, Length))
+            {
+                if (System.Math.Abs(Cross(relativeStart, direction)) > Epsilon)
+                    return false;
+                var a = Dot(relativeStart, direction);
+                var b = Dot(End - origin, direction);
+                var low = System.Math.Max(0, System.Math.Min(a, b));
+                var high = System.Math.Min(length, System.Math.Max(a, b));
+                return high > Epsilon && low <= high + Epsilon;
+            }
+            var distanceAlongRapid = Cross(relativeStart, edge) / denominator;
+            var fractionAlongEdge = Cross(relativeStart, direction) / denominator;
+            return distanceAlongRapid > Epsilon && distanceAlongRapid <= length + Epsilon
+                && fractionAlongEdge >= -Epsilon / System.Math.Max(Length, Epsilon)
+                && fractionAlongEdge <= 1 + Epsilon / System.Math.Max(Length, Epsilon);
+        }
+
+        internal bool CrossesRay(Vector point)
+        {
+            if (Center is not { } center)
+                return (Start.Y > point.Y) != (End.Y > point.Y)
+                    && Start.X + (point.Y - Start.Y) * (End.X - Start.X) / (End.Y - Start.Y) > point.X;
+
+            // Split arcs at vertical extrema, giving monotone-Y pieces. Apply the same
+            // half-open endpoint rule as a polygon ray test, solving X on the native
+            // circle. This handles full circles, reversed arcs and shared vertices.
+            var breaks = new List<double> { 0, System.Math.Abs(Sweep) };
+            foreach (var angle in new[] { System.Math.PI / 2, 3 * System.Math.PI / 2 })
+            {
+                var travel = Travel(angle);
+                if (travel > 0 && travel < System.Math.Abs(Sweep))
+                    breaks.Add(travel);
+            }
+            breaks.Sort();
+            var inside = false;
+            for (var i = 1; i < breaks.Count; i++)
+            {
+                var a = StartAngle + System.Math.Sign(Sweep) * breaks[i - 1];
+                var b = StartAngle + System.Math.Sign(Sweep) * breaks[i];
+                var ya = i == 1 ? Start.Y : center.Y + Radius * System.Math.Sin(a);
+                var yb = i == breaks.Count - 1 ? End.Y : center.Y + Radius * System.Math.Sin(b);
+                if ((ya > point.Y) == (yb > point.Y))
+                    continue;
+                var dy = point.Y - center.Y;
+                var dx = System.Math.Sqrt(System.Math.Max(0, Radius * Radius - dy * dy));
+                var x = center.X + (System.Math.Cos((a + b) / 2) >= 0 ? dx : -dx);
+                if (x > point.X)
+                    inside = !inside;
+            }
+            return inside;
+        }
+    }
+}

OpenNest.Core/Diagnostics/PostVerificationReport.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OpenNest.Diagnostics;
+
+public enum PostVerificationKind
+{
+    Overlap,
+    MissingLeadIn,
+    RapidCrossing,
+    Incomplete
+}
+
+/// <summary>Plate and part numbers are one-based; plate zero denotes a whole-post limitation.</summary>
+public sealed record PostVerificationFinding(PostVerificationKind Kind, int PlateNumber,
+    int? PartNumber, int? OtherPartNumber, string Message);
+
+/// <summary>Owned, immutable findings. Consent is evaluated afresh, never stored.</summary>
+public sealed class PostVerificationReport
+{
+    internal PostVerificationReport(IEnumerable<PostVerificationFinding> findings)
+    {
+        Findings = Array.AsReadOnly(findings.ToArray());
+    }
+
+    public IReadOnlyList<PostVerificationFinding> Findings { get; }
+    public bool HasWarnings => Findings.Count != 0;
+    public bool CanPost(bool risksAcknowledged) => !HasWarnings || risksAcknowledged;
+
+    public string ToDisplayText()
+    {
+        var text = new StringBuilder();
+        text.AppendLine("Pre-post verification");
+        var incomplete = Findings.Any(finding => finding.Kind == PostVerificationKind.Incomplete);
+        Summary(PostVerificationKind.Overlap, "Overlap");
+        Summary(PostVerificationKind.MissingLeadIn, "Missing lead-ins");
+        Summary(PostVerificationKind.RapidCrossing, "Rapid crossings");
+        foreach (var finding in Findings)
+        {
+            text.Append(finding.PlateNumber == 0 ? "Post processor" : $"Plate {finding.PlateNumber}");
+            if (finding.PartNumber is { } part)
+                text.Append($", part {part}");
+            if (finding.OtherPartNumber is { } other)
+                text.Append($", other part {other}");
+            text.AppendLine($": {finding.Kind}: {finding.Message}");
+        }
+        text.AppendLine("This is not a physical safety certification. The check uses direct XY rapids " +
+            "in plate/program order; the post may change order, routing or retracts. Inspect the posted " +
+            "machine program and machine setup. Actual contour gaps are not proof of adequate retention.");
+        return text.ToString();
+
+        void Summary(PostVerificationKind kind, string label)
+        {
+            var count = Findings.Count(finding => finding.Kind == kind);
+            text.AppendLine($"{label}: {count} warning(s)" +
+                (incomplete ? "; verification incomplete — do not treat as clear." : "."));
+        }
+    }
+}

OpenNest.Core/DrawingProgramSnapshot.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using OpenNest.CNC;
+
+namespace OpenNest;
+
+/// <summary>
+/// Captures drawing program text before an edit and rebuilds only the parts whose
+/// drawing program changed. Drawing keys use reference identity because names are editable.
+/// </summary>
+public sealed class DrawingProgramSnapshot
+{
+    private readonly Dictionary<Drawing, string> programs;
+    private readonly Func<Program, string> fingerprint;
+
+    private DrawingProgramSnapshot(
+        Dictionary<Drawing, string> programs,
+        Func<Program, string> fingerprint)
+    {
+        this.programs = programs;
+        this.fingerprint = fingerprint;
+    }
+
+    /// <summary>
+    /// Capture before handing drawings to an editor, including its load operation:
+    /// programs can be edited in place. The callback must include both the main
+    /// program text and its hole sub-programs, and must not mutate the program.
+    /// </summary>
+    public static DrawingProgramSnapshot Capture(
+        IEnumerable<Drawing> drawings,
+        Func<Program, string> fingerprint)
+    {
+        ArgumentNullException.ThrowIfNull(drawings);
+        ArgumentNullException.ThrowIfNull(fingerprint);
+        var programs = new Dictionary<Drawing, string>(ReferenceEqualityComparer.Instance);
+
+        foreach (var drawing in drawings)
+        {
+            if (!drawing.IsCutOff && !programs.ContainsKey(drawing))
+                programs.Add(drawing, fingerprint(drawing.Program));
+        }
+
+        return new DrawingProgramSnapshot(programs, fingerprint);
+    }
+
+    /// <summary>
+    /// Complete the captured edit by rebuilding changed drawings' parts across all plates.
+    /// Part.Update preserves the placement and clears obsolete lead-ins, tabs and locks.
+    /// Unchanged and uncaptured drawings' parts retain their program instances and state.
+    /// Returns the rebuilt parts so a UI can invalidate just their graphics.
+    /// </summary>
+    public IReadOnlyList<Part> UpdateChangedParts(IEnumerable<Plate> plates)
+    {
+        ArgumentNullException.ThrowIfNull(plates);
+        var changed = new HashSet<Drawing>(ReferenceEqualityComparer.Instance);
+
+        foreach (var entry in programs)
+        {
+            if (!entry.Key.IsCutOff
+                && !string.Equals(entry.Value, fingerprint(entry.Key.Program), StringComparison.Ordinal))
+                changed.Add(entry.Key);
+        }
+
+        var updated = new List<Part>();
+        foreach (var plate in plates)
+        {
+            foreach (var part in plate.Parts)
+            {
+                if (!changed.Contains(part.BaseDrawing))
+                    continue;
+
+                part.Update();
+                updated.Add(part);
+            }
+        }
+
+        return updated;
+    }
+}

OpenNest.Core/Geometry/Clearance.cs

@@ -0,0 +1,336 @@
+using System;
+using System.Collections.Generic;
+using OpenNest.Math;
+
+namespace OpenNest.Geometry
+{
+    /// <summary>
+    /// Signed clearance between two closed polygons, plus the unit direction that
+    /// increases it by moving the first polygon.
+    /// </summary>
+    public struct ClearanceResult
+    {
+        /// <summary>
+        /// &gt; 0: minimum boundary distance. 0: touching. &lt; 0: penetration depth
+        /// (the translation of <c>a</c> along <see cref="Direction"/> needed to end
+        /// contact).
+        /// </summary>
+        public double Distance;
+
+        /// <summary>
+        /// Unit direction for translating <c>a</c> away from <c>b</c>. For penetration
+        /// this is the minimum-translation direction. Never zero-length; degenerate
+        /// (coincident-centroid) penetration resolves to a deterministic axis.
+        /// </summary>
+        public Vector Direction;
+
+        public ClearanceResult(double distance, Vector direction)
+        {
+            Distance = distance;
+            Direction = direction;
+        }
+    }
+
+    /// <summary>
+    /// Omnidirectional clearance between two closed, lines-only polygons.
+    /// Complements <see cref="SpatialQuery.DirectionalDistance"/> (movement along a
+    /// fixed ray) with the all-directions minimum distance and separating direction,
+    /// and <see cref="Collision"/> (boolean overlap) with depth and direction.
+    /// <para>
+    /// Reference quality, not hot-loop quality: separation is a brute-force
+    /// segment-pair minimum with a bounding-box reject, penetration is a
+    /// separating-axis sweep over both polygons' edge normals. The overlap verdict
+    /// defers to <see cref="Collision.HasOverlap(Polygon, Polygon, List{Polygon}, List{Polygon})"/>
+    /// so callers that validate with Collision never see a disagreeing kernel.
+    /// Rings with holes are handled by the caller: pass every ring pair (a part's
+    /// material boundary is its outer ring plus its hole rings).
+    /// </para>
+    /// </summary>
+    public static class Clearance
+    {
+        public static ClearanceResult Between(Polygon a, Polygon b)
+        {
+            var linesA = a.ToLines();
+            var linesB = b.ToLines();
+
+            if (linesA.Count == 0 || linesB.Count == 0)
+                return new ClearanceResult(0, new Vector(1, 0));
+
+            if (Collision.HasOverlap(a, b))
+                return Penetration(linesA, linesB);
+
+            return Separation(linesA, linesB);
+        }
+
+        /// <summary>
+        /// Non-negative minimum boundary (edge-to-edge) distance between two rings
+        /// and the direction that translates <paramref name="a"/> away from
+        /// <paramref name="b"/> at the closest contact. Never tests overlap: a ring
+        /// contained in another (a part inside a cutout ring) still reports its true
+        /// gap. For signed material clearance use <see cref="Between"/>.
+        /// </summary>
+        public static ClearanceResult BoundaryDistance(Polygon a, Polygon b)
+        {
+            var linesA = a.ToLines();
+            var linesB = b.ToLines();
+
+            if (linesA.Count == 0 || linesB.Count == 0)
+                return new ClearanceResult(0, new Vector(1, 0));
+
+            return Separation(linesA, linesB);
+        }
+
+        /// <summary>
+        /// Minimum boundary distance between two non-overlapping rings and the
+        /// direction that translates <paramref name="linesA"/> away from
+        /// <paramref name="linesB"/> at the closest contact.
+        /// </summary>
+        private static ClearanceResult Separation(List<Line> linesA, List<Line> linesB)
+        {
+            var minDist = double.MaxValue;
+            var pa = Vector.Zero;
+            var pb = Vector.Zero;
+
+            var boxes = new Box[linesB.Count];
+            for (var i = 0; i < linesB.Count; i++)
+                boxes[i] = SegmentBox(linesB[i]);
+
+            foreach (var la in linesA)
+            {
+                var boxA = SegmentBox(la);
+
+                for (var i = 0; i < linesB.Count; i++)
+                {
+                    if (!BoxesWithin(boxA, boxes[i], minDist))
+                        continue;
+
+                    var d = SegmentDistance(la, linesB[i], out var qa, out var qb);
+                    if (d < minDist)
+                    {
+                        minDist = d;
+                        pa = qa;
+                        pb = qb;
+                    }
+                }
+            }
+
+            var dir = pa - pb;
+            var len = Magnitude(dir);
+
+            if (len <= Tolerance.Epsilon)
+                dir = CentroidAway(linesA, linesB);
+            else
+                dir = dir / len;
+
+            return new ClearanceResult(minDist, dir);
+        }
+
+        /// <summary>
+        /// Penetration depth and minimum-translation direction along the separating-
+        /// axis candidates of both rings. Per candidate axis the true translation
+        /// depth is used (exit distance to the far side), so containment reports the
+        /// depth that actually ends contact, not the interval-intersection length.
+        /// Depth is reported as a negative clearance.
+        /// </summary>
+        private static ClearanceResult Penetration(List<Line> linesA, List<Line> linesB)
+        {
+            var ca = Centroid(linesA);
+            var cb = Centroid(linesB);
+
+            var bestDepth = double.MaxValue;
+            var bestDir = new Vector(1, 0);
+
+            var bestAxis = -1;
+
+            for (var axis = 0; axis < 2; axis++)
+            {
+                var lines = axis == 0 ? linesA : linesB;
+
+                foreach (var line in lines)
+                {
+                    var edge = line.pt2 - line.pt1;
+                    var n = new Vector(edge.Y, -edge.X);
+                    var len = Magnitude(n);
+                    if (len <= Tolerance.Epsilon)
+                        continue;
+                    n = n / len;
+
+                    var (minA, maxA) = Project(linesA, n);
+                    var (minB, maxB) = Project(linesB, n);
+
+                    if (maxA <= minB || maxB <= minA)
+                        continue; // separating axis found
+
+                    // Depth pushing a away from b along ±n.
+                    var forward = maxB - minA; // move a in +n until minA >= maxB
+                    var backward = maxA - minB; // move a in -n until maxA <= minB
+
+                    double depth;
+                    Vector dir;
+                    if (forward <= backward)
+                    {
+                        depth = forward;
+                        dir = n;
+                    }
+                    else
+                    {
+                        depth = backward;
+                        dir = -n;
+                    }
+
+                    if (depth < bestDepth - Tolerance.Epsilon || bestAxis < 0)
+                    {
+                        bestDepth = depth;
+                        bestDir = dir;
+                        bestAxis = axis;
+                    }
+                }
+            }
+
+            if (bestAxis < 0)
+            {
+                // No candidate axis (degenerate rings): deterministic fallback.
+                var away = ca - cb;
+                var len = Magnitude(away);
+                bestDir = len > Tolerance.Epsilon ? away / len : new Vector(1, 0);
+                bestDepth = 0;
+            }
+
+            return new ClearanceResult(-bestDepth, bestDir);
+        }
+
+        private static Vector CentroidAway(List<Line> linesA, List<Line> linesB)
+        {
+            var away = Centroid(linesA) - Centroid(linesB);
+            var len = Magnitude(away);
+            return len > Tolerance.Epsilon ? away / len : new Vector(1, 0);
+        }
+
+        private static Vector Centroid(List<Line> lines)
+        {
+            var sum = Vector.Zero;
+            foreach (var line in lines)
+            {
+                sum += line.pt1;
+                sum += line.pt2;
+            }
+            return sum / (2 * lines.Count);
+        }
+
+        private static (double Min, double Max) Project(List<Line> lines, Vector n)
+        {
+            var min = double.MaxValue;
+            var max = double.MinValue;
+
+            foreach (var line in lines)
+            {
+                var d1 = line.pt1.DotProduct(n);
+                var d2 = line.pt2.DotProduct(n);
+                if (d1 < min)
+                    min = d1;
+                if (d1 > max)
+                    max = d1;
+                if (d2 < min)
+                    min = d2;
+                if (d2 > max)
+                    max = d2;
+            }
+
+            return (min, max);
+        }
+
+        /// <summary>
+        /// Minimum distance between two segments with the closest points.
+        /// Non-parallel segments use the classic clamped closest-point solve;
+        /// (near-)parallel segments fall back to the four endpoint-to-segment
+        /// distances, which is where the minimum always lies.
+        /// </summary>
+        private static double SegmentDistance(Line a, Line b, out Vector pa, out Vector pb)
+        {
+            var p = a.pt1;
+            var r = a.pt2 - a.pt1;
+            var q = b.pt1;
+            var s = b.pt2 - b.pt1;
+
+            var rxr = r.DotProduct(r);
+            var sxs = s.DotProduct(s);
+            var rxs = r.DotProduct(s);
+
+            const double eps = 1e-12;
+
+            var denom = rxr * sxs - rxs * rxs;
+            if (denom > eps && rxr > eps && sxs > eps)
+            {
+                // Minimize |(p + r t) - (q + s u)|^2; setting both partials to
+                // zero and solving (Cramer) with d0 = p - q:
+                //   t = ((r.s)(d0.s) - (d0.r)(s.s)) / (rr.ss - (r.s)^2)
+                //   u = ((r.r)(d0.s) - (r.s)(d0.r)) / (rr.ss - (r.s)^2)
+                var d0 = p - q;
+                var d0r = d0.DotProduct(r);
+                var d0s = d0.DotProduct(s);
+
+                var t = Clamp((rxs * d0s - d0r * sxs) / denom, 0, 1);
+                var u = Clamp((rxs * t + d0s) / sxs, 0, 1); // nearest u on b for clamped t
+                t = Clamp((rxs * u - d0r) / rxr, 0, 1); // re-solve t for clamped u
+
+                pa = p + r * t;
+                pb = q + s * u;
+                return pa.DistanceTo(pb);
+            }
+
+            // Degenerate or parallel: the minimum is attained at an endpoint.
+            var bestPa = p;
+            var bestPb = q;
+            var best = double.MaxValue;
+
+            void Consider(Vector pt, Line seg, bool ptOnA)
+            {
+                var d = seg.pt2 - seg.pt1;
+                var len2 = d.DotProduct(d);
+                var u = len2 <= eps ? 0 : Clamp((pt - seg.pt1).DotProduct(d) / len2, 0, 1);
+                var on = seg.pt1 + d * u;
+                var dist = pt.DistanceTo(on);
+                if (dist < best)
+                {
+                    best = dist;
+                    bestPa = ptOnA ? pt : on;
+                    bestPb = ptOnA ? on : pt;
+                }
+            }
+
+            Consider(p, b, true);
+            Consider(a.pt2, b, true);
+            Consider(q, a, false);
+            Consider(b.pt2, a, false);
+
+            pa = bestPa;
+            pb = bestPb;
+            return best;
+        }
+
+        private static double Clamp(double v, double lo, double hi) =>
+            v < lo ? lo : (v > hi ? hi : v);
+
+        private static double Magnitude(Vector v) => System.Math.Sqrt(v.X * v.X + v.Y * v.Y);
+
+        private static Box SegmentBox(Line line)
+        {
+            return new Box(
+                System.Math.Min(line.pt1.X, line.pt2.X),
+                System.Math.Min(line.pt1.Y, line.pt2.Y),
+                System.Math.Abs(line.pt2.X - line.pt1.X),
+                System.Math.Abs(line.pt2.Y - line.pt1.Y)
+            );
+        }
+
+        private static bool BoxesWithin(Box a, Box b, double distance)
+        {
+            return !(
+                a.Right + distance < b.Left
+                || b.Right + distance < a.Left
+                || a.Top + distance < b.Bottom
+                || b.Top + distance < a.Bottom
+            );
+        }
+    }
+}

OpenNest.Core/Geometry/ConvexDecomposition.cs

@@ -148,14 +148,12 @@ namespace OpenNest.Geometry
         /// </summary>
         private static double SignedArea(List<Vector> verts)
         {
+            // World-coordinate products can erase the sign of a small polygon's area
+            // far from the origin, leaving CW outlines/holes untriangulated. Measure
+            // relative to a vertex, just as the clipping kernel measures its fragments.
             var area = 0.0;
-
+            for (var i = 1; i + 1 < verts.Count; i++)
-            for (var i = 0; i < verts.Count; i++)
+                area += Cross(verts[0], verts[i], verts[i + 1]);
-            {
-                var j = (i + 1) % verts.Count;
-                area += verts[i].X * verts[j].Y;
-                area -= verts[j].X * verts[i].Y;
-            }
 
             return area * 0.5;
         }

OpenNest.Core/Geometry/PolygonAreaMoments.cs

@@ -0,0 +1,101 @@
+using System.Collections.Generic;
+
+namespace OpenNest.Geometry;
+
+/// <summary>
+/// Positive area and area centroid of a simple polygon, independent of winding.
+/// Moments are evaluated about a nearby origin rather than the world origin.
+/// </summary>
+public readonly struct PolygonAreaMoments
+{
+    private PolygonAreaMoments(double area, Vector centroid)
+    {
+        Area = area;
+        Centroid = centroid;
+    }
+
+    public double Area { get; }
+    public Vector Centroid { get; }
+
+    /// <summary>
+    /// Accepts an open vertex list or an exactly repeated closing vertex. Returns false
+    /// for degenerate or nonfinite moments; does not validate polygon topology.
+    /// </summary>
+    public static bool TryCompute(IReadOnlyList<Vector> vertices, out PolygonAreaMoments moments)
+    {
+        moments = default;
+        if (vertices == null || vertices.Count < 3)
+            return false;
+        foreach (var point in vertices)
+            if (!IsFinite(point))
+                return false;
+
+        var origin = vertices[0];
+        var count = vertices.Count;
+        if (vertices[count - 1].X == origin.X && vertices[count - 1].Y == origin.Y)
+            count--;
+        if (count < 3)
+            return false;
+
+        var twiceArea = 0.0;
+        var momentX = 0.0;
+        var momentY = 0.0;
+        // The closing edges meet the local origin and contribute zero. The signed
+        // triangle fan also handles concavity without averaging polygon vertices.
+        for (var i = 1; i + 1 < count; i++)
+        {
+            var a = vertices[i] - origin;
+            var b = vertices[i + 1] - origin;
+            var cross = a.X * b.Y - a.Y * b.X;
+            twiceArea += cross;
+            momentX += (a.X + b.X) * cross;
+            momentY += (a.Y + b.Y) * cross;
+        }
+
+        var area = System.Math.Abs(twiceArea) * 0.5;
+        if (!double.IsFinite(area) || area <= 0
+            || !double.IsFinite(momentX) || !double.IsFinite(momentY))
+            return false;
+        // Dividing signed moments by signed area cancels the winding, while Area
+        // stays positive so independently wound fragments always add material.
+        var centroid = origin + new Vector(momentX / twiceArea / 3, momentY / twiceArea / 3);
+        if (!IsFinite(centroid))
+            return false;
+        moments = new PolygonAreaMoments(area, centroid);
+        return true;
+    }
+
+    /// <summary>
+    /// Combines nonoverlapping, already hole-subtracted fragments using positive area
+    /// weights and another local origin. The centroid may lie outside the material.
+    /// Empty input or any invalid fragment fails the entire result.
+    /// </summary>
+    public static bool TryCombine(IEnumerable<PolygonAreaMoments> fragments, out PolygonAreaMoments moments)
+    {
+        moments = default;
+        if (fragments == null)
+            return false;
+        var area = 0.0;
+        var origin = Vector.Zero;
+        var firstMoment = Vector.Zero;
+        foreach (var fragment in fragments)
+        {
+            if (!double.IsFinite(fragment.Area) || fragment.Area <= 0 || !IsFinite(fragment.Centroid))
+                return false;
+            if (area == 0)
+                origin = fragment.Centroid;
+            firstMoment += (fragment.Centroid - origin) * fragment.Area;
+            area += fragment.Area;
+        }
+
+        if (!double.IsFinite(area) || area <= 0 || !IsFinite(firstMoment))
+            return false;
+        var centroid = origin + firstMoment / area;
+        if (!IsFinite(centroid))
+            return false;
+        moments = new PolygonAreaMoments(area, centroid);
+        return true;
+    }
+
+    private static bool IsFinite(Vector point) => double.IsFinite(point.X) && double.IsFinite(point.Y);
+}

OpenNest.Core/Geometry/SlideContact.cs

@@ -0,0 +1,831 @@
+using System.Collections.Generic;
+using OpenNest.Math;
+
+namespace OpenNest.Geometry
+{
+    internal enum ContactSide
+    {
+        /// <summary>The boundary could not be decomposed into closed loops.</summary>
+        Unresolved,
+
+        /// <summary>The point is not on the boundary: a tolerance near-miss, not a contact.</summary>
+        Off,
+
+        /// <summary>Several boundary runs meet here, or the corner is a cusp or spike.</summary>
+        Ambiguous,
+
+        /// <summary>The material sector is known.</summary>
+        Sector,
+    }
+
+    /// <summary>
+    /// Closed boundary loops of one entity list, prepared so a directional slide can tell
+    /// which side of each boundary point is material. Immutable after
+    /// <see cref="Prepare"/>, so one instance may be shared by concurrent queries.
+    /// </summary>
+    /// <remarks>
+    /// Loops are recovered from contiguous runs whose end points chain back to their start
+    /// (the order produced by <see cref="ShapeBuilder"/> and the offset helpers). Nesting
+    /// depth decides holes: material is inside even-depth loops and outside odd-depth ones.
+    /// When the list cannot be decomposed that way, every contact query is unresolved.
+    /// </remarks>
+    public sealed class SlideContactGeometry
+    {
+        // Contact points are computed from unsnapped ray parameters, so a genuine contact is
+        // on both boundaries to floating-point accuracy. This also bounds the overlap sliver a
+        // tangential classification can admit, so keep it far below spacing tolerances.
+        internal const double IncidenceTolerance = 1e-7;
+
+        private readonly List<Entity> entities;
+        private readonly int[] loopOf;
+        private readonly int[] previous;
+        private readonly int[] following;
+        private readonly bool[] materialLeft;
+
+        private SlideContactGeometry(
+            List<Entity> entities,
+            int[] loopOf,
+            int[] previous,
+            int[] following,
+            bool[] materialLeft
+        )
+        {
+            this.entities = entities;
+            this.loopOf = loopOf;
+            this.previous = previous;
+            this.following = following;
+            this.materialLeft = materialLeft;
+        }
+
+        /// <summary>True when every entity belongs to a closed loop with a known material side.</summary>
+        public bool IsResolved => materialLeft != null;
+
+        public static SlideContactGeometry Prepare(List<Entity> entities)
+        {
+            var count = entities.Count;
+            var loopOf = new int[count];
+            var previous = new int[count];
+            var following = new int[count];
+            var loops = new List<(int First, int Last)>();
+
+            var i = 0;
+            while (i < count)
+            {
+                var first = i;
+                if (entities[i] is Circle)
+                {
+                    i++;
+                }
+                else
+                {
+                    if (!TryEndpoints(entities[i], out var start, out _))
+                        return Unresolved(entities);
+
+                    var closed = false;
+                    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.
+                        if (Near(end, start) && (i > first || entities[i] is Arc))
+                        {
+                            closed = true;
+                            i++;
+                            break;
+                        }
+
+                        if (
+                            i + 1 >= count
+                            || !TryEndpoints(entities[i + 1], out var nextStart, out _)
+                            || !Near(nextStart, end)
+                        )
+                            break;
+
+                        i++;
+                    }
+
+                    if (!closed)
+                        return Unresolved(entities);
+                }
+
+                var loop = loops.Count;
+                loops.Add((first, i - 1));
+                for (var k = first; k < i; k++)
+                {
+                    loopOf[k] = loop;
+                    previous[k] = k == first ? i - 1 : k - 1;
+                    following[k] = k == i - 1 ? first : k + 1;
+                }
+            }
+
+            var materialLeft = new bool[loops.Count];
+
+            for (var loop = 0; loop < loops.Count; loop++)
+            {
+                var area = SignedArea(entities, loops[loop].First, loops[loop].Last);
+                if (System.Math.Abs(area) <= Tolerance.Epsilon)
+                    return Unresolved(entities);
+
+                var depth = 0;
+                if (loops.Count > 1)
+                {
+                    var sample = SamplePoint(entities[loops[loop].First]);
+                    for (var other = 0; other < loops.Count; other++)
+                    {
+                        if (other == loop)
+                            continue;
+                        if (Contains(entities, loops[other].First, loops[other].Last, sample))
+                            depth++;
+                    }
+                }
+
+                materialLeft[loop] = (area > 0) == (depth % 2 == 0);
+            }
+
+            return new SlideContactGeometry(entities, loopOf, previous, following, materialLeft);
+        }
+
+        private static SlideContactGeometry Unresolved(List<Entity> entities) =>
+            new SlideContactGeometry(entities, null, null, null, null);
+
+        /// <summary>
+        /// Material directions at a boundary point: an angular sector starting at
+        /// <paramref name="start"/> and sweeping CCW by <paramref name="width"/>.
+        /// Concavity is recorded separately at each sector ray: only the supporting
+        /// curve, not an unrelated curve at that corner, can block a tangential slide.
+        /// Entities wholly inside the incidence tolerance are treated as part of the corner.
+        /// </summary>
+        internal ContactSide GetMaterialSector(
+            Vector point,
+            out double start,
+            out double width,
+            out bool startConcave,
+            out bool endConcave
+        )
+        {
+            start = width = 0;
+            startConcave = endConcave = false;
+            if (materialLeft == null)
+                return ContactSide.Unresolved;
+
+            var best = -1;
+            var bestDistance = double.MaxValue;
+            for (var i = 0; i < entities.Count; i++)
+            {
+                var distance = DistanceTo(entities[i], point);
+                if (distance < bestDistance)
+                {
+                    bestDistance = distance;
+                    best = i;
+                }
+            }
+
+            if (best < 0 || bestDistance > IncidenceTolerance)
+                return ContactSide.Off;
+
+            // Walk to the entities that enter and leave the tolerance disc.
+            var loopLength = LoopLength(best);
+            var incoming = best;
+            var steps = 0;
+            var smoothLoop = loopLength == 1 && (entities[best] is Circle
+                || entities[best] is Arc fullArc && fullArc.IsFullCircle());
+            while (!smoothLoop && StartsNear(incoming, point))
+            {
+                incoming = previous[incoming];
+                if (++steps >= loopLength)
+                    return ContactSide.Ambiguous;
+            }
+
+            var outgoing = best;
+            steps = 0;
+            while (!smoothLoop && EndsNear(outgoing, point))
+            {
+                outgoing = following[outgoing];
+                if (++steps >= loopLength)
+                    return ContactSide.Ambiguous;
+            }
+
+            // Anything else touching this point (another loop, a spike, a self-crossing)
+            // makes the local material side ambiguous.
+            for (var i = 0; i < entities.Count; i++)
+            {
+                if (InRun(i, incoming, outgoing))
+                    continue;
+                if (DistanceTo(entities[i], point) <= IncidenceTolerance)
+                    return ContactSide.Ambiguous;
+            }
+
+            var interior = incoming == best && outgoing == best && !EndsNear(best, point);
+            var inTangent = interior ? TangentAt(entities[best], point) : EndTangent(entities[incoming]);
+            var outTangent = interior
+                ? inTangent
+                : StartTangent(entities[outgoing]);
+
+            // A circle has no endpoints, so its point is always interior.
+            if (smoothLoop)
+                inTangent = outTangent = TangentAt(entities[best], point);
+
+            if (IsZero(inTangent) || IsZero(outTangent))
+                return ContactSide.Ambiguous;
+
+            var outAngle = System.Math.Atan2(outTangent.Y, outTangent.X);
+            var inAngle = System.Math.Atan2(-inTangent.Y, -inTangent.X);
+            var left = materialLeft[loopOf[best]];
+
+            start = left ? outAngle : inAngle;
+            width = Angle.NormalizeRad((left ? inAngle : outAngle) - start);
+
+            startConcave = IsConcave(entities[left ? outgoing : incoming], left);
+            endConcave = IsConcave(entities[left ? incoming : outgoing], left);
+
+            return
+                width > SlideContact.AngleTolerance
+                && width < Angle.TwoPI - 2 * SlideContact.SplitOverlap
+                ? ContactSide.Sector
+                : ContactSide.Ambiguous;
+        }
+
+        private int LoopLength(int index)
+        {
+            var length = 1;
+            for (var i = following[index]; i != index; i = following[i])
+                length++;
+            return length;
+        }
+
+        private bool StartsNear(int index, Vector point) =>
+            TryEndpoints(entities[index], out var start, out _)
+            && start.DistanceTo(point) <= IncidenceTolerance;
+
+        private bool EndsNear(int index, Vector point) =>
+            TryEndpoints(entities[index], out _, out var end)
+            && end.DistanceTo(point) <= IncidenceTolerance;
+
+        private bool InRun(int index, int first, int last)
+        {
+            for (var i = first; ; i = following[i])
+            {
+                if (i == index)
+                    return true;
+                if (i == last)
+                    return false;
+            }
+        }
+
+        private static bool IsZero(Vector v) => v.X == 0 && v.Y == 0;
+
+        private static bool IsConcave(Entity entity, bool materialLeft)
+        {
+            // A CCW curve has its center on its left; that center is on the free side
+            // (a concave boundary) exactly when material is on the right.
+            return entity switch
+            {
+                Arc arc => materialLeft == arc.IsReversed,
+                Circle circle => materialLeft == (circle.Rotation == RotationType.CW),
+                _ => false,
+            };
+        }
+
+        private static Vector StartTangent(Entity entity) =>
+            entity switch
+            {
+                Line line => Direction(line.pt1, line.pt2),
+                Arc arc => ArcTangent(arc.StartAngle, arc.IsReversed),
+                _ => new Vector(),
+            };
+
+        private static Vector EndTangent(Entity entity) =>
+            entity switch
+            {
+                Line line => Direction(line.pt1, line.pt2),
+                Arc arc => ArcTangent(arc.EndAngle, arc.IsReversed),
+                _ => new Vector(),
+            };
+
+        private static Vector TangentAt(Entity entity, Vector point) =>
+            entity switch
+            {
+                Line line => Direction(line.pt1, line.pt2),
+                Arc arc => ArcTangent(arc.Center.AngleTo(point), arc.IsReversed),
+                Circle circle => ArcTangent(
+                    circle.Center.AngleTo(point),
+                    circle.Rotation == RotationType.CW
+                ),
+                _ => new Vector(),
+            };
+
+        private static Vector ArcTangent(double angle, bool clockwise)
+        {
+            var sign = clockwise ? -1.0 : 1.0;
+            return new Vector(-System.Math.Sin(angle) * sign, System.Math.Cos(angle) * sign);
+        }
+
+        private static Vector Direction(Vector from, Vector to)
+        {
+            var dx = to.X - from.X;
+            var dy = to.Y - from.Y;
+            var length = System.Math.Sqrt(dx * dx + dy * dy);
+            return length > 0 ? new Vector(dx / length, dy / length) : new Vector();
+        }
+
+        private static double DistanceTo(Entity entity, Vector point)
+        {
+            switch (entity)
+            {
+                case Line line:
+                    return point.DistanceTo(line.ClosestPointTo(point));
+                case Arc arc:
+                    {
+                        var angle = arc.Center.AngleTo(point);
+                        if (Angle.IsBetweenRad(angle, arc.StartAngle, arc.EndAngle, arc.IsReversed))
+                            return System.Math.Abs(arc.Center.DistanceTo(point) - arc.Radius);
+                        return System.Math.Min(
+                            point.DistanceTo(arc.StartPoint()),
+                            point.DistanceTo(arc.EndPoint())
+                        );
+                    }
+                case Circle circle:
+                    return System.Math.Abs(circle.Center.DistanceTo(point) - circle.Radius);
+                default:
+                    return double.MaxValue;
+            }
+        }
+
+        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)
+        {
+            var area = 0.0;
+            for (var i = first; i <= last; i++)
+            {
+                switch (entities[i])
+                {
+                    case Circle circle:
+                        var sign = circle.Rotation == RotationType.CW ? -1 : 1;
+                        area += sign * System.Math.PI * circle.Radius * circle.Radius;
+                        break;
+                    case Line line:
+                        area += Cross(line.pt1, line.pt2) / 2;
+                        break;
+                    case Arc arc:
+                        var sweep = arc.IsReversed ? -arc.SweepAngle() : arc.SweepAngle();
+                        var r = arc.Radius;
+                        area += Cross(arc.StartPoint(), arc.EndPoint()) / 2;
+                        area += r * r / 2 * (sweep - System.Math.Sin(sweep));
+                        break;
+                }
+            }
+            return area;
+        }
+
+        private static double Cross(Vector a, Vector b) => a.X * b.Y - b.X * a.Y;
+
+        private static Vector SamplePoint(Entity entity) =>
+            entity switch
+            {
+                Circle circle => new Vector(circle.Center.X + circle.Radius, circle.Center.Y),
+                Arc arc => arc.StartPoint(),
+                Line line => line.pt1,
+                _ => new Vector(),
+            };
+
+        // Exact horizontal-ray parity. Split arcs at Y extrema so every piece is
+        // monotone; the same half-open endpoint rule as lines avoids seam double counts.
+        // A coarse inscribed polygon can misclassify thin rings as solid material.
+        private static bool Contains(List<Entity> entities, int first, int last, Vector point)
+        {
+            var inside = false;
+            for (var i = first; i <= last; i++)
+            {
+                if (entities[i] is Circle circle)
+                    return circle.Center.DistanceTo(point) < circle.Radius;
+                if (entities[i] is Line line)
+                {
+                    var a = line.pt1;
+                    var b = line.pt2;
+                    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;
+                }
+                else if (entities[i] is Arc arc)
+                {
+                    var sweep = arc.SweepAngle();
+                    var sign = arc.IsReversed ? -1.0 : 1.0;
+                    var cuts = new List<double> { 0, sweep };
+                    foreach (var extreme in new[] { Angle.HalfPI, 3 * Angle.HalfPI })
+                    {
+                        var t = Angle.NormalizeRad(sign * (extreme - arc.StartAngle));
+                        if (t > 0 && t < sweep)
+                            cuts.Add(t);
+                    }
+                    cuts.Sort();
+                    for (var k = 1; k < cuts.Count; k++)
+                    {
+                        var a = arc.StartAngle + sign * cuts[k - 1];
+                        var b = arc.StartAngle + sign * cuts[k];
+                        var y1 = arc.Center.Y + arc.Radius * System.Math.Sin(a);
+                        var y2 = arc.Center.Y + arc.Radius * System.Math.Sin(b);
+                        if ((y1 > point.Y) == (y2 > point.Y))
+                            continue;
+                        var dy = point.Y - arc.Center.Y;
+                        var dx = System.Math.Sqrt(System.Math.Max(0, arc.Radius * arc.Radius - dy * dy));
+                        var x = arc.Center.X + (System.Math.Cos((a + b) / 2) >= 0 ? dx : -dx);
+                        if (point.X < x)
+                            inside = !inside;
+                    }
+                }
+            }
+            return inside;
+        }
+    }
+
+    /// <summary>
+    /// Contact classifier for one moving/stationary pair of boundaries. Geometry is prepared
+    /// on first use, so a slide whose nearest contact is never classified pays nothing; call
+    /// <see cref="Prepare"/> before sharing one instance across threads. Each boundary is
+    /// given in its own frame; the origins place those frames in the world coordinates used
+    /// by slide events.
+    /// </summary>
+    public sealed class SlideContactClassifier
+    {
+        private readonly System.Func<List<Entity>> movingSource;
+        private readonly System.Func<List<Entity>> stationarySource;
+        private SlideContactGeometry moving;
+        private SlideContactGeometry stationary;
+
+        public SlideContactClassifier(List<Entity> movingEntities, List<Entity> stationaryEntities)
+            : this(movingEntities, Vector.Zero, stationaryEntities, Vector.Zero) { }
+
+        public SlideContactClassifier(
+            List<Entity> movingEntities,
+            Vector movingOrigin,
+            List<Entity> stationaryEntities,
+            Vector stationaryOrigin
+        )
+            : this(() => movingEntities, movingOrigin, () => stationaryEntities, stationaryOrigin)
+        { }
+
+        public SlideContactClassifier(
+            SlideContactGeometry moving,
+            Vector movingOrigin,
+            SlideContactGeometry stationary,
+            Vector stationaryOrigin
+        )
+        {
+            this.moving = moving;
+            this.stationary = stationary;
+            MovingOrigin = movingOrigin;
+            StationaryOrigin = stationaryOrigin;
+        }
+
+        private SlideContactClassifier(
+            System.Func<List<Entity>> movingSource,
+            Vector movingOrigin,
+            System.Func<List<Entity>> stationarySource,
+            Vector stationaryOrigin
+        )
+        {
+            this.movingSource = movingSource;
+            this.stationarySource = stationarySource;
+            MovingOrigin = movingOrigin;
+            StationaryOrigin = stationaryOrigin;
+        }
+
+        public Vector MovingOrigin { get; }
+
+        public Vector StationaryOrigin { get; }
+
+        public static SlideContactClassifier FromLines(
+            List<Line> movingLines,
+            Vector movingOrigin,
+            List<Line> stationaryLines,
+            Vector stationaryOrigin
+        ) =>
+            new SlideContactClassifier(
+                () => new List<Entity>(movingLines),
+                movingOrigin,
+                () => new List<Entity>(stationaryLines),
+                stationaryOrigin
+            );
+
+        public static SlideContactClassifier FromEdges(
+            (Vector start, Vector end)[] movingEdges,
+            Vector movingOrigin,
+            (Vector start, Vector end)[] stationaryEdges,
+            Vector stationaryOrigin
+        )
+        {
+            // The kernel sorts edge arrays in place, so snapshot the chain order now.
+            var moving = ((Vector start, Vector end)[])movingEdges.Clone();
+            var stationary = ((Vector start, Vector end)[])stationaryEdges.Clone();
+            return new SlideContactClassifier(
+                () => ToLines(moving),
+                movingOrigin,
+                () => ToLines(stationary),
+                stationaryOrigin
+            );
+        }
+
+        private static List<Entity> ToLines((Vector start, Vector end)[] edges)
+        {
+            var lines = new List<Entity>(edges.Length);
+            foreach (var (start, end) in edges)
+                lines.Add(new Line(start, end));
+            // Public edge arrays are sorted in place by previous queries. Recover their
+            // chains on private line objects; never reverse or reorder caller geometry.
+            var ordered = new List<Entity>(lines.Count);
+            foreach (var shape in ShapeBuilder.GetShapes(lines))
+                ordered.AddRange(shape.Entities);
+            return ordered;
+        }
+
+        public SlideContactClassifier Prepare()
+        {
+            moving ??= SlideContactGeometry.Prepare(movingSource?.Invoke() ?? new List<Entity>());
+            stationary ??= SlideContactGeometry.Prepare(
+                stationarySource?.Invoke() ?? new List<Entity>()
+            );
+            return this;
+        }
+
+        /// <summary>The same prepared boundaries placed at other origins.</summary>
+        public SlideContactClassifier At(Vector movingOrigin, Vector stationaryOrigin)
+        {
+            Prepare();
+            return new SlideContactClassifier(moving, movingOrigin, stationary, stationaryOrigin);
+        }
+
+        /// <summary>
+        /// True when moving along (dirX, dirY) from this world-space contact would push
+        /// material into material, or the contact cannot be classified.
+        /// </summary>
+        public bool Blocks(Vector movingPoint, Vector stationaryPoint, double dirX, double dirY)
+        {
+            Prepare();
+            return SlideContact.Blocks(
+                moving,
+                movingPoint - MovingOrigin,
+                stationary,
+                stationaryPoint - StationaryOrigin,
+                dirX,
+                dirY
+            );
+        }
+    }
+
+    /// <summary>Receives candidate contact events from a directional slide query.</summary>
+    public interface ISlideEventSink
+    {
+        /// <summary>True once further events cannot change this sink's result.</summary>
+        bool IsDone { get; }
+
+        /// <param name="distance">Travel to the contact, snapped to zero within Tolerance.Epsilon.</param>
+        /// <param name="movingPoint">Contact on the moving boundary, at its start position.</param>
+        /// <param name="stationaryPoint">Contact on the stationary boundary.</param>
+        void Add(double distance, Vector movingPoint, Vector stationaryPoint);
+    }
+
+    /// <summary>
+    /// Enumerates every candidate contact of one slide. Must yield the same events each
+    /// time it is enumerated.
+    /// </summary>
+    public interface ISlideEventSource
+    {
+        void Enumerate<TSink>(ref TSink sink)
+            where TSink : struct, ISlideEventSink;
+    }
+
+    /// <summary>Keeps the nearest event; stops at a contact that is already touching.</summary>
+    public struct NearestSlideEvent : ISlideEventSink
+    {
+        public bool Found;
+        public double Distance;
+        public Vector MovingPoint;
+        public Vector StationaryPoint;
+
+        public bool IsDone => Found && Distance <= 0;
+
+        public void Add(double distance, Vector movingPoint, Vector stationaryPoint)
+        {
+            if (Found && distance >= Distance)
+                return;
+
+            Found = true;
+            Distance = distance;
+            MovingPoint = movingPoint;
+            StationaryPoint = stationaryPoint;
+        }
+    }
+
+    internal struct SlideEventList : ISlideEventSink
+    {
+        public List<(double Distance, Vector MovingPoint, Vector StationaryPoint)> Events;
+
+        public bool IsDone => false;
+
+        public void Add(double distance, Vector movingPoint, Vector stationaryPoint) =>
+            Events.Add((distance, movingPoint, stationaryPoint));
+    }
+
+    public static class SlideResolver
+    {
+        /// <summary>
+        /// Travel to the first contact that blocks the slide, or double.MaxValue. When the
+        /// nearest contact blocks (every contact, for unresolved boundaries), the result is
+        /// exactly the nearest event distance and the events are enumerated once.
+        /// </summary>
+        public static double FirstBlocking<TSource>(
+            ref TSource source,
+            SlideContactClassifier contacts,
+            double dirX,
+            double dirY
+        )
+            where TSource : struct, ISlideEventSource
+        {
+            var nearest = new NearestSlideEvent();
+            source.Enumerate(ref nearest);
+
+            if (!nearest.Found)
+                return double.MaxValue;
+
+            if (contacts.Blocks(nearest.MovingPoint, nearest.StationaryPoint, dirX, dirY))
+                return nearest.Distance;
+
+            var all = new SlideEventList
+            {
+                Events = new List<(double, Vector, Vector)>(),
+            };
+            source.Enumerate(ref all);
+            all.Events.Sort((a, b) => a.Distance.CompareTo(b.Distance));
+
+            foreach (var (distance, movingPoint, stationaryPoint) in all.Events)
+            {
+                if (contacts.Blocks(movingPoint, stationaryPoint, dirX, dirY))
+                    return distance;
+            }
+
+            return double.MaxValue;
+        }
+    }
+
+    /// <summary>
+    /// Decides whether a first-contact event found by a directional slide stops the slide.
+    /// </summary>
+    /// <remarks>
+    /// Parts that already touch may slide along each other or apart. Only a direction that
+    /// would create positive-area overlap blocks: with S the stationary material sector and
+    /// M the moving one at the contact point, that is the open Minkowski cone S ⊕ −M.
+    /// A direction on that cone's boundary is a tangential slide; it blocks only when an
+    /// incident curve is concave, because the second-order bend then closes the gap.
+    /// Unresolved or ambiguous topology blocks, which is the previous behavior for every
+    /// contact.
+    /// </remarks>
+    public static class SlideContact
+    {
+        internal const double AngleTolerance = 1e-7;
+
+        // 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;
+
+        /// <summary>
+        /// True when moving along (dirX, dirY) from this contact would push material into
+        /// material, or when the contact cannot be classified. False for a near-miss whose
+        /// point is not on both boundaries.
+        /// </summary>
+        /// <param name="movingPoint">Contact point in the moving entities' own frame.</param>
+        /// <param name="stationaryPoint">The same contact in the stationary frame.</param>
+        public static bool Blocks(
+            SlideContactGeometry moving,
+            Vector movingPoint,
+            SlideContactGeometry stationary,
+            Vector stationaryPoint,
+            double dirX,
+            double dirY
+        )
+        {
+            if (moving == null || stationary == null)
+                return true;
+
+            var stationarySide = stationary.GetMaterialSector(
+                stationaryPoint,
+                out var stationaryStart,
+                out var stationaryWidth,
+                out var stationaryStartConcave,
+                out var stationaryEndConcave
+            );
+            var movingSide = moving.GetMaterialSector(
+                movingPoint,
+                out var movingStart,
+                out var movingWidth,
+                out var movingStartConcave,
+                out var movingEndConcave
+            );
+
+            if (stationarySide == ContactSide.Unresolved || movingSide == ContactSide.Unresolved)
+                return true;
+
+            // Ray tolerances report hits slightly beyond an entity's end; such a point is
+            // not on the other boundary, so the parts pass without touching there.
+            if (stationarySide == ContactSide.Off || movingSide == ContactSide.Off)
+                return false;
+
+            if (stationarySide == ContactSide.Ambiguous || movingSide == ContactSide.Ambiguous)
+                return true;
+
+            var direction = System.Math.Atan2(dirY, dirX);
+            var stationaryPieces = Split(stationaryStart, stationaryWidth);
+            var movingPieces = Split(movingStart + System.Math.PI, movingWidth);
+            var onBoundary = false;
+
+            foreach (var s in stationaryPieces)
+            {
+                foreach (var m in movingPieces)
+                {
+                    if (!TryHull(s, m, out var hullStart, out var hullWidth))
+                        return true;
+
+                    var offset = Angle.NormalizeRad(direction - hullStart);
+                    if (offset > AngleTolerance && offset < hullWidth - AngleTolerance)
+                        return true;
+
+                    if (
+                        offset <= AngleTolerance
+                        || offset >= Angle.TwoPI - AngleTolerance
+                        || System.Math.Abs(offset - hullWidth) <= AngleTolerance
+                    )
+                        onBoundary = true;
+                }
+            }
+
+            return onBoundary && (
+                stationaryStartConcave && SameRay(direction, stationaryStart)
+                || stationaryEndConcave && SameRay(direction, stationaryStart + stationaryWidth)
+                || movingStartConcave && SameRay(direction, movingStart + System.Math.PI)
+                || movingEndConcave && SameRay(direction, movingStart + movingWidth + System.Math.PI));
+        }
+
+        private static bool SameRay(double a, double b)
+        {
+            var offset = Angle.NormalizeRad(a - b);
+            return offset <= AngleTolerance || offset >= Angle.TwoPI - AngleTolerance;
+        }
+
+        private static (double Start, double Width)[] Split(double start, double width)
+        {
+            if (width <= System.Math.PI + AngleTolerance)
+                return new[] { (start, width) };
+
+            var half = width / 2;
+            return new[]
+            {
+                (start, half + SplitOverlap),
+                (start + half - SplitOverlap, half + SplitOverlap),
+            };
+        }
+
+        /// <summary>
+        /// Convex cone generated by two convex sectors. False when it is the whole plane.
+        /// </summary>
+        private static bool TryHull(
+            (double Start, double Width) a,
+            (double Start, double Width) b,
+            out double start,
+            out double width
+        )
+        {
+            var fromA = System.Math.Max(a.Width, Angle.NormalizeRad(b.Start - a.Start) + b.Width);
+            var fromB = System.Math.Max(b.Width, Angle.NormalizeRad(a.Start - b.Start) + a.Width);
+
+            if (fromA <= fromB)
+            {
+                start = a.Start;
+                width = fromA;
+            }
+            else
+            {
+                start = b.Start;
+                width = fromB;
+            }
+
+            return width <= System.Math.PI + AngleTolerance;
+        }
+    }
+}

OpenNest.Core/Geometry/SlideEvents.cs

@@ -0,0 +1,806 @@
+using System.Collections.Generic;
+using OpenNest.Math;
+
+namespace OpenNest.Geometry
+{
+    /// <summary>
+    /// Candidate contact events of directional slides. Each emitter reports every forward
+    /// hit its distance kernel considers, with the distance snapped exactly as that kernel
+    /// snaps it, so the nearest event equals the kernel's historical minimum.
+    /// </summary>
+    internal static class SlideEvents
+    {
+        private const double Eps = Tolerance.Epsilon;
+
+        private static double Snap(double t) => t > Eps ? t : 0;
+
+        /// <summary>
+        /// Ray from a vertex against one entity. When <paramref name="vertexMoves"/> is true
+        /// the vertex belongs to the moving boundary and the ray follows the push direction;
+        /// otherwise it is a stationary vertex and the ray runs opposite to the push.
+        /// </summary>
+        public static void Ray<TSink>(
+            ref TSink sink,
+            double vx,
+            double vy,
+            Entity entity,
+            double entityDx,
+            double entityDy,
+            double rayX,
+            double rayY,
+            bool vertexMoves
+        )
+            where TSink : struct, ISlideEventSink
+        {
+            switch (entity)
+            {
+                case Line line:
+                    RayLine(
+                        ref sink,
+                        vx,
+                        vy,
+                        line.pt1.X + entityDx,
+                        line.pt1.Y + entityDy,
+                        line.pt2.X + entityDx,
+                        line.pt2.Y + entityDy,
+                        rayX,
+                        rayY,
+                        vertexMoves
+                    );
+                    break;
+
+                case Arc arc:
+                    {
+                        var cx = arc.Center.X + entityDx;
+                        var cy = arc.Center.Y + entityDy;
+                        if (!SolveRayCircle(vx, vy, cx, cy, arc.Radius, rayX, rayY, out var t1, out var t2))
+                            return;
+
+                        for (var k = 0; k < 2; k++)
+                        {
+                            var t = k == 0 ? t1 : t2;
+                            if (t <= -Eps)
+                                continue;
+
+                            var hitAngle = Angle.NormalizeRad(
+                                System.Math.Atan2(vy + t * rayY - cy, vx + t * rayX - cx)
+                            );
+                            if (!Angle.IsBetweenRad(hitAngle, arc.StartAngle, arc.EndAngle, arc.IsReversed))
+                                continue;
+
+                            Emit(ref sink, vx, vy, t, rayX, rayY, vertexMoves);
+                            if (sink.IsDone)
+                                return;
+                        }
+                        break;
+                    }
+
+                case Circle circle:
+                    {
+                        if (
+                            !SolveRayCircle(
+                                vx,
+                                vy,
+                                circle.Center.X + entityDx,
+                                circle.Center.Y + entityDy,
+                                circle.Radius,
+                                rayX,
+                                rayY,
+                                out var t1,
+                                out var t2
+                            )
+                        )
+                            return;
+
+                        for (var k = 0; k < 2; k++)
+                        {
+                            var t = k == 0 ? t1 : t2;
+                            if (t < -Eps)
+                                continue;
+
+                            Emit(ref sink, vx, vy, t, rayX, rayY, vertexMoves);
+                            if (sink.IsDone)
+                                return;
+                        }
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>Same hit rule as <see cref="SpatialQuery.RayEdgeDistance(double, double, double, double, double, double, double, double)"/>.</summary>
+        public static void RayLine<TSink>(
+            ref TSink sink,
+            double vx,
+            double vy,
+            double p1x,
+            double p1y,
+            double p2x,
+            double p2y,
+            double rayX,
+            double rayY,
+            bool vertexMoves
+        )
+            where TSink : struct, ISlideEventSink
+        {
+            var ex = p2x - p1x;
+            var ey = p2y - p1y;
+
+            var det = ex * rayY - ey * rayX;
+            if (System.Math.Abs(det) < Eps)
+                return;
+
+            var dvx = p1x - vx;
+            var dvy = p1y - vy;
+
+            var t = (ex * dvy - ey * dvx) / det;
+            if (t < -Eps)
+                return;
+
+            var s = (rayX * dvy - rayY * dvx) / det;
+            if (s < -Eps || s > 1.0 + Eps)
+                return;
+
+            Emit(ref sink, vx, vy, t, rayX, rayY, vertexMoves);
+        }
+
+        /// <summary>
+        /// Axis-aligned ray against a segment, with the same hit rule as the
+        /// <see cref="PushDirection"/> kernel.
+        /// </summary>
+        public static void AxisRayLine<TSink>(
+            ref TSink sink,
+            double vx,
+            double vy,
+            double p1x,
+            double p1y,
+            double p2x,
+            double p2y,
+            PushDirection rayDirection,
+            bool vertexMoves
+        )
+            where TSink : struct, ISlideEventSink
+        {
+            double dist,
+                hx,
+                hy;
+
+            switch (rayDirection)
+            {
+                case PushDirection.Left:
+                case PushDirection.Right:
+                    {
+                        var dy = p2y - p1y;
+                        if (System.Math.Abs(dy) < Eps)
+                            return;
+
+                        var t = (vy - p1y) / dy;
+                        if (t < -Eps || t > 1.0 + Eps)
+                            return;
+
+                        hx = p1x + t * (p2x - p1x);
+                        hy = vy;
+                        dist = rayDirection == PushDirection.Left ? vx - hx : hx - vx;
+                        break;
+                    }
+
+                case PushDirection.Down:
+                case PushDirection.Up:
+                    {
+                        var dx = p2x - p1x;
+                        if (System.Math.Abs(dx) < Eps)
+                            return;
+
+                        var t = (vx - p1x) / dx;
+                        if (t < -Eps || t > 1.0 + Eps)
+                            return;
+
+                        hx = vx;
+                        hy = p1y + t * (p2y - p1y);
+                        dist = rayDirection == PushDirection.Down ? vy - hy : hy - vy;
+                        break;
+                    }
+
+                default:
+                    return;
+            }
+
+            if (dist < -Eps)
+                return;
+
+            var vertex = new Vector(vx, vy);
+            var hit = new Vector(hx, hy);
+            if (vertexMoves)
+                sink.Add(Snap(dist), vertex, hit);
+            else
+                sink.Add(Snap(dist), hit, vertex);
+        }
+
+        /// <summary>
+        /// Closest-approach points of arcs against lines, which vertex sampling can miss.
+        /// </summary>
+        public static void ArcToLine<TSink>(
+            ref TSink sink,
+            List<Entity> arcEntities,
+            double arcDx,
+            double arcDy,
+            List<Entity> lineEntities,
+            double lineDx,
+            double lineDy,
+            double rayX,
+            double rayY,
+            bool arcMoves
+        )
+            where TSink : struct, ISlideEventSink
+        {
+            for (var i = 0; i < arcEntities.Count; i++)
+            {
+                if (!TryGetCurve(arcEntities[i], out var localCx, out var localCy, out var r))
+                    continue;
+
+                var arc = arcEntities[i] as Arc;
+                var cx = localCx + arcDx;
+                var cy = localCy + arcDy;
+
+                for (var j = 0; j < lineEntities.Count; j++)
+                {
+                    if (lineEntities[j] is not Line line)
+                        continue;
+
+                    var p1x = line.pt1.X + lineDx;
+                    var p1y = line.pt1.Y + lineDy;
+                    var p2x = line.pt2.X + lineDx;
+                    var p2y = line.pt2.Y + lineDy;
+                    var ex = p2x - p1x;
+                    var ey = p2y - p1y;
+
+                    var det = ex * rayY - ey * rayX;
+                    if (System.Math.Abs(det) < Eps)
+                        continue;
+
+                    // The directional distance from an arc point at angle θ to the
+                    // line is t(θ) = [A + r·(ey·cosθ − ex·sinθ)] / det.
+                    // dt/dθ = 0 at θ = atan2(−ex, ey) and θ + π.
+                    var theta1 = Angle.NormalizeRad(System.Math.Atan2(-ex, ey));
+                    var theta2 = Angle.NormalizeRad(theta1 + System.Math.PI);
+
+                    for (var k = 0; k < 2; k++)
+                    {
+                        var theta = k == 0 ? theta1 : theta2;
+
+                        if (arc != null && !Angle.IsBetweenRad(theta, arc.StartAngle, arc.EndAngle, arc.IsReversed))
+                            continue;
+
+                        var qx = cx + r * System.Math.Cos(theta);
+                        var qy = cy + r * System.Math.Sin(theta);
+
+                        RayLine(ref sink, qx, qy, p1x, p1y, p2x, p2y, rayX, rayY, arcMoves);
+                        if (sink.IsDone)
+                            return;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// External and internal tangencies of two curves along a unit direction. Radii must
+        /// be nonnegative; a null arc is a full circle.
+        /// </summary>
+        public static void CurveTangency<TSink>(
+            ref TSink sink,
+            double movingCx,
+            double movingCy,
+            double movingRadius,
+            Arc movingArc,
+            double stationaryCx,
+            double stationaryCy,
+            double stationaryRadius,
+            Arc stationaryArc,
+            double dirX,
+            double dirY
+        )
+            where TSink : struct, ISlideEventSink
+        {
+            for (var kind = 0; kind < 2; kind++)
+            {
+                var internalContact = kind == 1;
+                var radius = internalContact
+                    ? System.Math.Abs(movingRadius - stationaryRadius)
+                    : movingRadius + stationaryRadius;
+
+                // Equal-radius internal contact has coincident centers, not a unique
+                // tangent point. Endpoints detect any overlap of those angular spans.
+                if (radius == 0)
+                    continue;
+
+                if (
+                    !SolveRayCircle(
+                        movingCx,
+                        movingCy,
+                        stationaryCx,
+                        stationaryCy,
+                        radius,
+                        dirX,
+                        dirY,
+                        out var t1,
+                        out var t2
+                    )
+                )
+                    continue;
+
+                // The nearer center-circle root can be outside an arc while the farther
+                // root is its first contact. Check the actual tangent point at BOTH roots.
+                for (var root = 0; root < 2; root++)
+                {
+                    var t = root == 0 ? t1 : t2;
+                    if (t < -Eps)
+                        continue;
+
+                    var toX = stationaryCx - (movingCx + t * dirX);
+                    var toY = stationaryCy - (movingCy + t * dirY);
+                    var movingSign = internalContact && movingRadius < stationaryRadius ? -1 : 1;
+                    var stationarySign = internalContact ? movingSign : -1;
+                    if (
+                        !ContainsContactAngle(
+                            movingArc,
+                            movingRadius,
+                            movingSign * toX,
+                            movingSign * toY
+                        )
+                        || !ContainsContactAngle(
+                            stationaryArc,
+                            stationaryRadius,
+                            stationarySign * toX,
+                            stationarySign * toY
+                        )
+                    )
+                        continue;
+
+                    var length = System.Math.Sqrt(toX * toX + toY * toY);
+                    var ux = length > 0 ? toX / length : 0;
+                    var uy = length > 0 ? toY / length : 0;
+                    var movingPoint = new Vector(
+                        movingCx + movingSign * movingRadius * ux,
+                        movingCy + movingSign * movingRadius * uy
+                    );
+                    var stationaryPoint = new Vector(
+                        stationaryCx + stationarySign * stationaryRadius * ux,
+                        stationaryCy + stationarySign * stationaryRadius * uy
+                    );
+
+                    sink.Add(Snap(t), movingPoint, stationaryPoint);
+                    if (sink.IsDone)
+                        return;
+                }
+            }
+        }
+
+        public static bool TryGetCurve(Entity entity, out double cx, out double cy, out double r)
+        {
+            switch (entity)
+            {
+                case Circle circle:
+                    cx = circle.Center.X;
+                    cy = circle.Center.Y;
+                    r = circle.Radius;
+                    return true;
+                case Arc arc:
+                    cx = arc.Center.X;
+                    cy = arc.Center.Y;
+                    r = arc.Radius;
+                    return true;
+                default:
+                    cx = cy = r = 0;
+                    return false;
+            }
+        }
+
+        private static void Emit<TSink>(
+            ref TSink sink,
+            double vx,
+            double vy,
+            double t,
+            double rayX,
+            double rayY,
+            bool vertexMoves
+        )
+            where TSink : struct, ISlideEventSink
+        {
+            var vertex = new Vector(vx, vy);
+            var hit = new Vector(vx + t * rayX, vy + t * rayY);
+            if (vertexMoves)
+                sink.Add(Snap(t), vertex, hit);
+            else
+                sink.Add(Snap(t), hit, vertex);
+        }
+
+        private static bool ContainsContactAngle(Arc arc, double radius, double x, double y)
+        {
+            // A zero-radius curve is a point: its angular range has no geometric meaning.
+            if (arc == null || radius == 0)
+                return true;
+            var angle = Angle.NormalizeRad(System.Math.Atan2(y, x));
+            return Angle.IsBetweenRad(angle, arc.StartAngle, arc.EndAngle, arc.IsReversed);
+        }
+
+        internal static bool SolveRayCircle(
+            double vx,
+            double vy,
+            double cx,
+            double cy,
+            double r,
+            double dirX,
+            double dirY,
+            out double t1,
+            out double t2
+        )
+        {
+            var ox = vx - cx;
+            var oy = vy - cy;
+
+            var a = dirX * dirX + dirY * dirY;
+            var b = 2.0 * (ox * dirX + oy * dirY);
+            var c = ox * ox + oy * oy - r * r;
+
+            var discriminant = b * b - 4.0 * a * c;
+            if (discriminant < 0)
+            {
+                t1 = t2 = double.MaxValue;
+                return false;
+            }
+
+            var sqrtD = System.Math.Sqrt(discriminant);
+            var inv2a = 1.0 / (2.0 * a);
+            t1 = (-b - sqrtD) * inv2a;
+            t2 = (-b + sqrtD) * inv2a;
+            return true;
+        }
+    }
+
+    /// <summary>
+    /// Slide events between native Line/Arc/Circle boundaries. The moving entities and
+    /// vertices are translated by (movingDx, movingDy); vertex arrays may be subsets.
+    /// </summary>
+    public struct EntitySlideEvents : ISlideEventSource
+    {
+        private readonly List<Entity> moving;
+        private readonly Vector[] movingVertices;
+        private readonly double movingDx;
+        private readonly double movingDy;
+        private readonly List<Entity> stationary;
+        private readonly Vector[] stationaryVertices;
+        private readonly double dirX;
+        private readonly double dirY;
+        private readonly bool arcToLine;
+
+        public EntitySlideEvents(
+            List<Entity> moving,
+            Vector[] movingVertices,
+            double movingDx,
+            double movingDy,
+            List<Entity> stationary,
+            Vector[] stationaryVertices,
+            double dirX,
+            double dirY,
+            bool arcToLine
+        )
+        {
+            this.moving = moving;
+            this.movingVertices = movingVertices;
+            this.movingDx = movingDx;
+            this.movingDy = movingDy;
+            this.stationary = stationary;
+            this.stationaryVertices = stationaryVertices;
+            this.dirX = dirX;
+            this.dirY = dirY;
+            this.arcToLine = arcToLine;
+        }
+
+        public void Enumerate<TSink>(ref TSink sink)
+            where TSink : struct, ISlideEventSink
+        {
+            // 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;
+
+                for (var j = 0; j < stationary.Count; j++)
+                {
+                    SlideEvents.Ray(ref sink, vx, vy, stationary[j], 0, 0, dirX, dirY, true);
+                    if (sink.IsDone)
+                        return;
+                }
+            }
+
+            // Phase 2: stationary vertices against the push onto moving entities.
+            for (var v = 0; v < stationaryVertices.Length; v++)
+            {
+                var vx = stationaryVertices[v].X;
+                var vy = stationaryVertices[v].Y;
+
+                for (var j = 0; j < moving.Count; j++)
+                {
+                    SlideEvents.Ray(
+                        ref sink,
+                        vx,
+                        vy,
+                        moving[j],
+                        movingDx,
+                        movingDy,
+                        -dirX,
+                        -dirY,
+                        false
+                    );
+                    if (sink.IsDone)
+                        return;
+                }
+            }
+
+            // Phase 3: arc-to-line closest points, which vertex sampling can miss.
+            if (arcToLine)
+            {
+                SlideEvents.ArcToLine(
+                    ref sink,
+                    moving,
+                    movingDx,
+                    movingDy,
+                    stationary,
+                    0,
+                    0,
+                    dirX,
+                    dirY,
+                    true
+                );
+                if (sink.IsDone)
+                    return;
+                SlideEvents.ArcToLine(
+                    ref sink,
+                    stationary,
+                    0,
+                    0,
+                    moving,
+                    movingDx,
+                    movingDy,
+                    -dirX,
+                    -dirY,
+                    false
+                );
+                if (sink.IsDone)
+                    return;
+            }
+
+            // Phase 4: native curve tangency, including a convex corner inside a concave arc.
+            for (var i = 0; i < moving.Count; i++)
+            {
+                if (!SlideEvents.TryGetCurve(moving[i], out var mcx, out var mcy, out var mr))
+                    continue;
+
+                for (var j = 0; j < stationary.Count; j++)
+                {
+                    if (!SlideEvents.TryGetCurve(stationary[j], out var scx, out var scy, out var sr))
+                        continue;
+
+                    SlideEvents.CurveTangency(
+                        ref sink,
+                        mcx + movingDx,
+                        mcy + movingDy,
+                        mr,
+                        moving[i] as Arc,
+                        scx,
+                        scy,
+                        sr,
+                        stationary[j] as Arc,
+                        dirX,
+                        dirY
+                    );
+                    if (sink.IsDone)
+                        return;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Slide events between line boundaries along an arbitrary unit direction. The moving
+    /// lines and vertices are translated by (movingDx, movingDy); vertex arrays may be subsets.
+    /// </summary>
+    public struct LineSlideEvents : ISlideEventSource
+    {
+        private readonly List<Line> moving;
+        private readonly Vector[] movingVertices;
+        private readonly double movingDx;
+        private readonly double movingDy;
+        private readonly List<Line> stationary;
+        private readonly Vector[] stationaryVertices;
+        private readonly double dirX;
+        private readonly double dirY;
+
+        public LineSlideEvents(
+            List<Line> moving,
+            Vector[] movingVertices,
+            double movingDx,
+            double movingDy,
+            List<Line> stationary,
+            Vector[] stationaryVertices,
+            double dirX,
+            double dirY
+        )
+        {
+            this.moving = moving;
+            this.movingVertices = movingVertices;
+            this.movingDx = movingDx;
+            this.movingDy = movingDy;
+            this.stationary = stationary;
+            this.stationaryVertices = stationaryVertices;
+            this.dirX = dirX;
+            this.dirY = dirY;
+        }
+
+        public void Enumerate<TSink>(ref TSink sink)
+            where TSink : struct, ISlideEventSink
+        {
+            for (var v = 0; v < movingVertices.Length; v++)
+            {
+                var vx = movingVertices[v].X + movingDx;
+                var vy = movingVertices[v].Y + movingDy;
+
+                for (var j = 0; j < stationary.Count; j++)
+                {
+                    var e = stationary[j];
+                    SlideEvents.RayLine(
+                        ref sink,
+                        vx,
+                        vy,
+                        e.pt1.X,
+                        e.pt1.Y,
+                        e.pt2.X,
+                        e.pt2.Y,
+                        dirX,
+                        dirY,
+                        true
+                    );
+                    if (sink.IsDone)
+                        return;
+                }
+            }
+
+            for (var v = 0; v < stationaryVertices.Length; v++)
+            {
+                var vx = stationaryVertices[v].X;
+                var vy = stationaryVertices[v].Y;
+
+                for (var j = 0; j < moving.Count; j++)
+                {
+                    var e = moving[j];
+                    SlideEvents.RayLine(
+                        ref sink,
+                        vx,
+                        vy,
+                        e.pt1.X + movingDx,
+                        e.pt1.Y + movingDy,
+                        e.pt2.X + movingDx,
+                        e.pt2.Y + movingDy,
+                        -dirX,
+                        -dirY,
+                        false
+                    );
+                    if (sink.IsDone)
+                        return;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Axis-aligned slide events between edge arrays sorted for pruning, as used by the
+    /// <see cref="PushDirection"/> kernel. Offsets translate each side into world space.
+    /// </summary>
+    public struct AxisSlideEvents : ISlideEventSource
+    {
+        private readonly (Vector start, Vector end)[] movingEdges;
+        private readonly Vector movingOffset;
+        private readonly Vector[] movingVertices;
+        private readonly (Vector start, Vector end)[] stationaryEdges;
+        private readonly Vector stationaryOffset;
+        private readonly Vector[] stationaryVertices;
+        private readonly PushDirection direction;
+
+        /// <param name="movingVertices">World-space moving vertices.</param>
+        /// <param name="stationaryVertices">World-space stationary vertices.</param>
+        public AxisSlideEvents(
+            (Vector start, Vector end)[] movingEdges,
+            Vector movingOffset,
+            Vector[] movingVertices,
+            (Vector start, Vector end)[] stationaryEdges,
+            Vector stationaryOffset,
+            Vector[] stationaryVertices,
+            PushDirection direction
+        )
+        {
+            this.movingEdges = movingEdges;
+            this.movingOffset = movingOffset;
+            this.movingVertices = movingVertices;
+            this.stationaryEdges = stationaryEdges;
+            this.stationaryOffset = stationaryOffset;
+            this.stationaryVertices = stationaryVertices;
+            this.direction = direction;
+        }
+
+        public void Enumerate<TSink>(ref TSink sink)
+            where TSink : struct, ISlideEventSink
+        {
+            for (var v = 0; v < movingVertices.Length; v++)
+            {
+                OneWay(ref sink, movingVertices[v], stationaryEdges, stationaryOffset, direction, true);
+                if (sink.IsDone)
+                    return;
+            }
+
+            var opposite = SpatialQuery.OppositeDirection(direction);
+            for (var v = 0; v < stationaryVertices.Length; v++)
+            {
+                OneWay(ref sink, stationaryVertices[v], movingEdges, movingOffset, opposite, false);
+                if (sink.IsDone)
+                    return;
+            }
+        }
+
+        private static void OneWay<TSink>(
+            ref TSink sink,
+            Vector vertex,
+            (Vector start, Vector end)[] edges,
+            Vector edgeOffset,
+            PushDirection rayDirection,
+            bool vertexMoves
+        )
+            where TSink : struct, ISlideEventSink
+        {
+            var vx = vertex.X;
+            var vy = vertex.Y;
+            var horizontal = SpatialQuery.IsHorizontalDirection(rayDirection);
+
+            // Edges are sorted by their perpendicular min-coordinate.
+            for (var i = 0; i < edges.Length; i++)
+            {
+                var e1 = edges[i].start + edgeOffset;
+                var e2 = edges[i].end + edgeOffset;
+
+                double perpValue,
+                    edgeMin,
+                    edgeMax;
+                if (horizontal)
+                {
+                    perpValue = vy;
+                    edgeMin = e1.Y < e2.Y ? e1.Y : e2.Y;
+                    edgeMax = e1.Y > e2.Y ? e1.Y : e2.Y;
+                }
+                else
+                {
+                    perpValue = vx;
+                    edgeMin = e1.X < e2.X ? e1.X : e2.X;
+                    edgeMax = e1.X > e2.X ? e1.X : e2.X;
+                }
+
+                if (perpValue < edgeMin - Tolerance.Epsilon)
+                    break;
+
+                if (perpValue > edgeMax + Tolerance.Epsilon)
+                    continue;
+
+                SlideEvents.AxisRayLine(
+                    ref sink,
+                    vx,
+                    vy,
+                    e1.X,
+                    e1.Y,
+                    e2.X,
+                    e2.Y,
+                    rayDirection,
+                    vertexMoves
+                );
+                if (sink.IsDone)
+                    return;
+            }
+        }
+    }
+}

OpenNest.Core/Geometry/SpatialQuery.cs

@@ -320,8 +320,9 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Computes the minimum translation distance along a push direction before
+        /// Computes the translation distance along a push direction before any edge of
-        /// any edge of movingLines contacts any edge of stationaryLines.
+        /// movingLines first blocks against an edge of stationaryLines. A contact that
+        /// the push slides along or leaves does not block (see <see cref="SlideContact"/>).
         /// Returns double.MaxValue if no collision path exists.
         /// </summary>
         public static double DirectionalDistance(
@@ -334,7 +335,7 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Computes the minimum directional distance with the moving lines translated
+        /// Computes the directional distance with the moving lines translated
         /// by (movingDx, movingDy) without creating new Line objects.
         /// </summary>
         public static double DirectionalDistance(
@@ -345,37 +346,57 @@ namespace OpenNest.Geometry
             PushDirection direction
         )
         {
-            var minDist = double.MaxValue;
+            return DirectionalDistance(
-            var movingOffset = new Vector(movingDx, movingDy);
+                movingLines,
+                movingDx,
+                movingDy,
+                stationaryLines,
+                direction,
+                SlideContactClassifier.FromLines(
+                    movingLines,
+                    new Vector(movingDx, movingDy),
+                    stationaryLines,
+                    Vector.Zero
+                )
+            );
+        }
 
-            // Case 1: Each moving vertex -> each stationary edge
+        /// <summary>
-            var movingVertices = CollectVertices(movingLines, movingOffset);
+        /// <see cref="DirectionalDistance(List{Line}, double, double, List{Line}, PushDirection)"/>
+        /// with caller-supplied contact topology, for inputs that are not complete closed
+        /// boundaries (for example direction-filtered edges).
+        /// </summary>
+        public static double DirectionalDistance(
+            List<Line> movingLines,
+            double movingDx,
+            double movingDy,
+            List<Line> stationaryLines,
+            PushDirection direction,
+            SlideContactClassifier contacts
+        )
+        {
+            var movingOffset = new Vector(movingDx, movingDy);
+            var movingVertices = CollectVertices(movingLines, movingOffset).ToArray();
 
             var stationaryEdges = ToEdgeArray(stationaryLines);
             SortEdgesForPruning(stationaryEdges, direction);
 
-            foreach (var mv in movingVertices)
+            var stationaryVertices = CollectVertices(stationaryLines, Vector.Zero).ToArray();
-            {
-                var d = OneWayDistance(mv, stationaryEdges, Vector.Zero, direction);
-                if (d < minDist)
-                    minDist = d;
-            }
-
-            // Case 2: Each stationary vertex -> each moving edge (opposite direction)
-            var opposite = OppositeDirection(direction);
-            var stationaryVertices = CollectVertices(stationaryLines, Vector.Zero);
 
             var movingEdges = ToEdgeArray(movingLines);
-            SortEdgesForPruning(movingEdges, opposite);
+            SortEdgesForPruning(movingEdges, OppositeDirection(direction));
 
-            foreach (var sv in stationaryVertices)
+            var source = new AxisSlideEvents(
-            {
+                movingEdges,
-                var d = OneWayDistance(sv, movingEdges, movingOffset, opposite);
+                movingOffset,
-                if (d < minDist)
+                movingVertices,
-                    minDist = d;
+                stationaryEdges,
-            }
+                Vector.Zero,
-
+                stationaryVertices,
-            return minDist;
+                direction
+            );
+            var unit = DirectionToOffset(direction, 1.0);
+            return SlideResolver.FirstBlocking(ref source, contacts, unit.X, unit.Y);
         }
 
         /// <summary>
@@ -396,8 +417,8 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Computes the minimum directional distance using raw edge arrays and location offsets
+        /// Computes the blocking directional distance using raw edge arrays and location
-        /// to avoid all intermediate object allocations.
+        /// offsets. Sorts both edge arrays in place for pruning.
         /// </summary>
         public static double DirectionalDistance(
             (Vector start, Vector end)[] movingEdges,
@@ -407,36 +428,58 @@ namespace OpenNest.Geometry
             PushDirection direction
         )
         {
-            var minDist = double.MaxValue;
+            return DirectionalDistance(
+                movingEdges,
+                movingOffset,
+                stationaryEdges,
+                stationaryOffset,
+                direction,
+                SlideContactClassifier.FromEdges(
+                    movingEdges,
+                    movingOffset,
+                    stationaryEdges,
+                    stationaryOffset
+                )
+            );
+        }
 
+        /// <summary>
+        /// Edge-array overload with caller-supplied contact topology. The classifier's
+        /// origins must match <paramref name="movingOffset"/> and
+        /// <paramref name="stationaryOffset"/> in the frame of its boundaries.
+        /// </summary>
+        public static double DirectionalDistance(
+            (Vector start, Vector end)[] movingEdges,
+            Vector movingOffset,
+            (Vector start, Vector end)[] stationaryEdges,
+            Vector stationaryOffset,
+            PushDirection direction,
+            SlideContactClassifier contacts
+        )
+        {
             SortEdgesForPruning(stationaryEdges, direction);
+            var movingVertices = CollectVertices(movingEdges, movingOffset).ToArray();
 
-            // Case 1: Each moving vertex -> each stationary edge
+            SortEdgesForPruning(movingEdges, OppositeDirection(direction));
-            var movingVertices = CollectVertices(movingEdges, movingOffset);
+            var stationaryVertices = CollectVertices(stationaryEdges, stationaryOffset).ToArray();
 
-            foreach (var mv in movingVertices)
+            var source = new AxisSlideEvents(
-            {
+                movingEdges,
-                var d = OneWayDistance(mv, stationaryEdges, stationaryOffset, direction);
+                movingOffset,
-                if (d < minDist)
+                movingVertices,
-                    minDist = d;
+                stationaryEdges,
-            }
+                stationaryOffset,
-
+                stationaryVertices,
-            // Case 2: Each stationary vertex -> each moving edge (opposite direction)
+                direction
-            var opposite = OppositeDirection(direction);
+            );
-            SortEdgesForPruning(movingEdges, opposite);
+            var unit = DirectionToOffset(direction, 1.0);
-
+            return SlideResolver.FirstBlocking(ref source, contacts, unit.X, unit.Y);
-            var stationaryVertices = CollectVertices(stationaryEdges, stationaryOffset);
-
-            foreach (var sv in stationaryVertices)
-            {
-                var d = OneWayDistance(sv, movingEdges, movingOffset, opposite);
-                if (d < minDist)
-                    minDist = d;
-            }
-
-            return minDist;
         }
 
+        /// <summary>
+        /// Nearest raw hit from one vertex along a push direction against edges sorted for
+        /// pruning. This is a first-touch primitive; it does not classify sliding contacts.
+        /// </summary>
         public static double OneWayDistance(
             Vector vertex,
             (Vector start, Vector end)[] edges,
@@ -628,8 +671,8 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Computes the minimum translation distance along an arbitrary unit direction
+        /// Computes the translation distance along an arbitrary unit direction before any
-        /// before any edge of movingLines contacts any edge of stationaryLines.
+        /// edge of movingLines first blocks against an edge of stationaryLines.
         /// </summary>
         public static double DirectionalDistance(
             List<Line> movingLines,
@@ -637,58 +680,41 @@ namespace OpenNest.Geometry
             Vector direction
         )
         {
-            var minDist = double.MaxValue;
+            return DirectionalDistance(
-            var dirX = direction.X;
+                movingLines,
-            var dirY = direction.Y;
+                stationaryLines,
-
+                direction,
-            var movingVertices = CollectVertices(movingLines, Vector.Zero);
+                SlideContactClassifier.FromLines(
-
+                    movingLines,
-            foreach (var mv in movingVertices)
+                    Vector.Zero,
-            {
+                    stationaryLines,
-                for (var i = 0; i < stationaryLines.Count; i++)
+                    Vector.Zero
-                {
+                )
-                    var e = stationaryLines[i];
-                    var d = RayEdgeDistance(
-                        mv.X,
-                        mv.Y,
-                        e.pt1.X,
-                        e.pt1.Y,
-                        e.pt2.X,
-                        e.pt2.Y,
-                        dirX,
-                        dirY
             );
-                    if (d < minDist)
-                        minDist = d;
-                }
         }
 
-            var oppX = -dirX;
+        /// <summary>
-            var oppY = -dirY;
+        /// <see cref="DirectionalDistance(List{Line}, List{Line}, Vector)"/> with
-
+        /// caller-supplied contact topology.
-            var stationaryVertices = CollectVertices(stationaryLines, Vector.Zero);
+        /// </summary>
-
+        public static double DirectionalDistance(
-            foreach (var sv in stationaryVertices)
+            List<Line> movingLines,
+            List<Line> stationaryLines,
+            Vector direction,
+            SlideContactClassifier contacts
+        )
         {
-                for (var i = 0; i < movingLines.Count; i++)
+            var source = new LineSlideEvents(
-                {
+                movingLines,
-                    var e = movingLines[i];
+                CollectVertices(movingLines, Vector.Zero).ToArray(),
-                    var d = RayEdgeDistance(
+                0,
-                        sv.X,
+                0,
-                        sv.Y,
+                stationaryLines,
-                        e.pt1.X,
+                CollectVertices(stationaryLines, Vector.Zero).ToArray(),
-                        e.pt1.Y,
+                direction.X,
-                        e.pt2.X,
+                direction.Y
-                        e.pt2.Y,
-                        oppX,
-                        oppY
             );
-                    if (d < minDist)
+            return SlideResolver.FirstBlocking(ref source, contacts, direction.X, direction.Y);
-                        minDist = d;
-                }
-            }
-
-            return minDist;
         }
 
         /// <summary>
@@ -710,10 +736,10 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Computes the minimum translation distance along an arbitrary unit direction
+        /// Computes the translation distance along an arbitrary unit direction before any
-        /// before any vertex/edge of movingEntities contacts any vertex/edge of
+        /// vertex/edge of movingEntities first blocks against stationaryEntities. Works with
-        /// stationaryEntities. Works with native Line, Arc, and Circle entities
+        /// native Line, Arc, and Circle entities without tessellation. A contact that the
-        /// without tessellation.
+        /// push slides along or leaves does not block (see <see cref="SlideContact"/>).
         /// </summary>
         public static double DirectionalDistance(
             List<Entity> movingEntities,
@@ -721,228 +747,42 @@ namespace OpenNest.Geometry
             Vector direction
         )
         {
-            var minDist = double.MaxValue;
+            return DirectionalDistance(
-            var dirX = direction.X;
-            var dirY = direction.Y;
-
-            var movingVertices = ExtractEntityVertices(movingEntities);
-
-            for (var v = 0; v < movingVertices.Length; v++)
-            {
-                var vx = movingVertices[v].X;
-                var vy = movingVertices[v].Y;
-
-                for (var j = 0; j < stationaryEntities.Count; j++)
-                {
-                    var d = RayEntityDistance(vx, vy, stationaryEntities[j], dirX, dirY);
-                    if (d < minDist)
-                    {
-                        minDist = d;
-                        if (d <= 0)
-                            return 0;
-                    }
-                }
-            }
-
-            var oppX = -dirX;
-            var oppY = -dirY;
-
-            var stationaryVertices = ExtractEntityVertices(stationaryEntities);
-
-            for (var v = 0; v < stationaryVertices.Length; v++)
-            {
-                var vx = stationaryVertices[v].X;
-                var vy = stationaryVertices[v].Y;
-
-                for (var j = 0; j < movingEntities.Count; j++)
-                {
-                    var d = RayEntityDistance(vx, vy, movingEntities[j], oppX, oppY);
-                    if (d < minDist)
-                    {
-                        minDist = d;
-                        if (d <= 0)
-                            return 0;
-                    }
-                }
-            }
-
-            // Phase 3: Arc-to-line closest-point check.
-            // Phases 1-2 sample arc endpoints and cardinal extremes, but the actual
-            // closest point on a small corner arc to a straight edge may lie between
-            // those samples. Use ClosestPointTo to find it and fire a ray from there.
-            minDist = ArcToLineClosestDistance(
                 movingEntities,
                 stationaryEntities,
-                dirX,
+                direction,
-                dirY,
+                new SlideContactClassifier(movingEntities, stationaryEntities)
-                minDist
             );
-            if (minDist <= 0)
+        }
-                return 0;
+
-            minDist = ArcToLineClosestDistance(
+        /// <summary>
-                stationaryEntities,
+        /// <see cref="DirectionalDistance(List{Entity}, List{Entity}, Vector)"/> with
+        /// caller-supplied contact topology.
+        /// </summary>
+        public static double DirectionalDistance(
+            List<Entity> movingEntities,
+            List<Entity> stationaryEntities,
+            Vector direction,
+            SlideContactClassifier contacts
+        )
+        {
+            // Phases: vertex rays both ways, arc-to-line closest points (vertex sampling
+            // misses interior arc contact), then native curve tangency.
+            var source = new EntitySlideEvents(
                 movingEntities,
-                oppX,
+                ExtractEntityVertices(movingEntities),
-                oppY,
+                0,
-                minDist
+                0,
+                stationaryEntities,
+                ExtractEntityVertices(stationaryEntities),
+                direction.X,
+                direction.Y,
+                arcToLine: true
             );
-            if (minDist <= 0)
+            return SlideResolver.FirstBlocking(ref source, contacts, direction.X, direction.Y);
-                return 0;
-
-            // Phase 4: Native curve tangency, including a convex corner inside a concave arc.
-            for (var i = 0; i < movingEntities.Count; i++)
-            {
-                var me = movingEntities[i];
-                if (!TryGetCurveParams(me, out var mcx, out var mcy, out var mr))
-                    continue;
-
-                for (var j = 0; j < stationaryEntities.Count; j++)
-                {
-                    var se = stationaryEntities[j];
-                    if (!TryGetCurveParams(se, out var scx, out var scy, out var sr))
-                        continue;
-
-                    var d = CurveTangencyDistance(
-                        mcx, mcy, mr, me as Arc,
-                        scx, scy, sr, se as Arc, dirX, dirY);
-                    if (d >= minDist)
-                        continue;
-
-                    minDist = d;
-                    if (d <= 0)
-                        return 0;
-                }
         }
 
-            return minDist;
+        public static Vector[] ExtractEntityVertices(List<Entity> entities)
-        }
-
-        private static double ArcToLineClosestDistance(
-            List<Entity> arcEntities,
-            List<Entity> lineEntities,
-            double dirX,
-            double dirY,
-            double minDist
-        )
-        {
-            for (var i = 0; i < arcEntities.Count; i++)
-            {
-                if (arcEntities[i] is not Arc arc)
-                    continue;
-
-                var cx = arc.Center.X;
-                var cy = arc.Center.Y;
-                var r = arc.Radius;
-
-                for (var j = 0; j < lineEntities.Count; j++)
-                {
-                    if (lineEntities[j] is not Line line)
-                        continue;
-
-                    var p1x = line.pt1.X;
-                    var p1y = line.pt1.Y;
-                    var ex = line.pt2.X - p1x;
-                    var ey = line.pt2.Y - p1y;
-
-                    var det = ex * dirY - ey * dirX;
-                    if (System.Math.Abs(det) < Tolerance.Epsilon)
-                        continue;
-
-                    // The directional distance from an arc point at angle θ to the
-                    // line is t(θ) = [A + r·(ey·cosθ − ex·sinθ)] / det.
-                    // dt/dθ = 0 at θ = atan2(−ex, ey) and θ + π.
-                    var theta1 = Angle.NormalizeRad(System.Math.Atan2(-ex, ey));
-                    var theta2 = Angle.NormalizeRad(theta1 + System.Math.PI);
-
-                    for (var k = 0; k < 2; k++)
-                    {
-                        var theta = k == 0 ? theta1 : theta2;
-
-                        if (
-                            !Angle.IsBetweenRad(theta, arc.StartAngle, arc.EndAngle, arc.IsReversed)
-                        )
-                            continue;
-
-                        var qx = cx + r * System.Math.Cos(theta);
-                        var qy = cy + r * System.Math.Sin(theta);
-
-                        var d = RayEdgeDistance(
-                            qx,
-                            qy,
-                            p1x,
-                            p1y,
-                            line.pt2.X,
-                            line.pt2.Y,
-                            dirX,
-                            dirY
-                        );
-                        if (d < minDist)
-                        {
-                            minDist = d;
-                            if (d <= 0)
-                                return 0;
-                        }
-                    }
-                }
-            }
-            return minDist;
-        }
-
-        private static double RayEntityDistance(
-            double vx,
-            double vy,
-            Entity entity,
-            double dirX,
-            double dirY
-        )
-        {
-            if (entity is Line line)
-            {
-                return RayEdgeDistance(
-                    vx,
-                    vy,
-                    line.pt1.X,
-                    line.pt1.Y,
-                    line.pt2.X,
-                    line.pt2.Y,
-                    dirX,
-                    dirY
-                );
-            }
-
-            if (entity is Arc arc)
-            {
-                return RayArcDistance(
-                    vx,
-                    vy,
-                    arc.Center.X,
-                    arc.Center.Y,
-                    arc.Radius,
-                    arc.StartAngle,
-                    arc.EndAngle,
-                    arc.IsReversed,
-                    dirX,
-                    dirY
-                );
-            }
-
-            if (entity is Circle circle)
-            {
-                return RayCircleDistance(
-                    vx,
-                    vy,
-                    circle.Center.X,
-                    circle.Center.Y,
-                    circle.Radius,
-                    dirX,
-                    dirY
-                );
-            }
-
-            return double.MaxValue;
-        }
-
-        private static Vector[] ExtractEntityVertices(List<Entity> entities)
         {
             var vertices = new HashSet<Vector>();
 
@@ -1041,31 +881,6 @@ namespace OpenNest.Geometry
                 );
         }
 
-        private static bool TryGetCurveParams(
-            Entity entity,
-            out double cx,
-            out double cy,
-            out double r
-        )
-        {
-            if (entity is Circle circle)
-            {
-                cx = circle.Center.X;
-                cy = circle.Center.Y;
-                r = circle.Radius;
-                return true;
-            }
-            if (entity is Arc arc)
-            {
-                cx = arc.Center.X;
-                cy = arc.Center.Y;
-                r = arc.Radius;
-                return true;
-            }
-            cx = cy = r = 0;
-            return false;
-        }
-
         private static double BoxProjectionMin(Box box, double dx, double dy)
         {
             var x = dx >= 0 ? box.Left : box.Right;

OpenNest.Core/IMultiFilePostProcessor.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace OpenNest
+{
+    /// <summary>
+    /// A post-processor whose <see cref="IPostProcessor.Post(Nest, string)"/>
+    /// can write more than one file (for example one program per sheet).
+    /// </summary>
+    public interface IMultiFilePostProcessor : IPostProcessor
+    {
+        /// <summary>
+        /// The files <see cref="IPostProcessor.Post(Nest, string)"/> will write
+        /// for this nest and chosen path, in order, with the current settings.
+        /// </summary>
+        IReadOnlyList<string> GetOutputFiles(Nest nest, string outputFile);
+    }
+}

OpenNest.Core/IPostVerificationSupport.cs

@@ -0,0 +1,13 @@
+namespace OpenNest;
+
+/// <summary>
+/// Optional post contract for nest-level rapid verification. Opt in only when the
+/// post preserves Plate.Parts order and each placed Program's contour order and
+/// pierce positions. This does not certify retract height, parking or controller macros.
+/// Unknown/reordering posts still get nest diagnostics, but require acknowledgment
+/// that their final rapid sequence has not been verified.
+/// </summary>
+public interface IPostVerificationSupport
+{
+    bool PreservesPlacedProgramOrder { get; }
+}

OpenNest.Core/Nest.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using OpenNest.Collections;
 using OpenNest.Geometry;
@@ -38,6 +38,10 @@ namespace OpenNest
 
         public string AssistGas { get; set; } = "";
 
+        public NestStatus Status { get; set; } = NestStatus.Quote;
+
+        public string MadeBy { get; set; } = "";
+
         public double Thickness { get; set; }
 
         public Material Material { get; set; }

OpenNest.Core/NestStatus.cs

@@ -0,0 +1,13 @@
+namespace OpenNest
+{
+    /// <summary>
+    /// Shop-floor workflow state of a saved nest, persisted as a string in
+    /// <c>nest.json</c> so unknown future values can fall back safely.
+    /// </summary>
+    public enum NestStatus
+    {
+        Quote,
+        ToBeCut,
+        HasBeenCut,
+    }
+}

OpenNest.Core/Part.cs

@@ -111,6 +111,30 @@ namespace OpenNest
             UpdateBounds();
         }
 
+        /// <summary>
+        /// Installs an owned, already-rotated saved cutting program without rotating it again.
+        /// The current pose remains the clean-drawing pose used by RemoveLeadIns.
+        /// </summary>
+        public bool RestoreLeadInProgram(Program program, bool locked)
+        {
+            if (program == null || !program.Codes.Any(code => code is Motion
+                || code is SubProgramCall call && call.Program != null
+                    && call.Program.Codes.Any(subCode => subCode is Motion)))
+                return false;
+
+            // Compute before changing state, so a malformed program cannot half-install.
+            var bounds = program.BoundingBox();
+            bounds.Offset(Location);
+            preLeadInRotation = Rotation;
+            Program = program;
+            ownsProgram = true;
+            HasManualLeadIns = true;
+            LeadInsLocked = locked;
+            CuttingParameters = null;
+            BoundingBox = bounds;
+            return true;
+        }
+
         public void RemoveLeadIns()
         {
             var rotation = preLeadInRotation;
@@ -145,7 +169,7 @@ namespace OpenNest
             EnsureOwnedProgram();
             Program.Rotate(angle);
             location = Location.Rotate(angle);
-            preLeadInRotation = Program.Rotation;
+            TrackRotation(angle);
             UpdateBounds();
         }
 
@@ -159,10 +183,22 @@ namespace OpenNest
             EnsureOwnedProgram();
             Program.Rotate(angle);
             location = Location.Rotate(angle, origin);
-            preLeadInRotation = Program.Rotation;
+            TrackRotation(angle);
             UpdateBounds();
         }
 
+        /// <summary>
+        /// Records the part's rotation after it turned by <paramref name="angle"/>. A lead-in
+        /// program is rebuilt by the cutting strategy and starts over at zero program
+        /// rotation, so for those parts the rotation is accumulated rather than read back.
+        /// </summary>
+        private void TrackRotation(double angle)
+        {
+            preLeadInRotation = HasManualLeadIns
+                ? Angle.NormalizeRad(preLeadInRotation + angle)
+                : Program.Rotation;
+        }
+
         /// <summary>
         /// Offsets the part.
         /// </summary>
@@ -323,6 +359,7 @@ namespace OpenNest
                 new Box(BoundingBox.X, BoundingBox.Y, BoundingBox.Length, BoundingBox.Width)
             );
             part.ownsProgram = true;
+            part.CopyLeadInStateFrom(this);
 
             return part;
         }
@@ -347,10 +384,24 @@ namespace OpenNest
                     BoundingBox.Width
                 )
             );
+            part.CopyLeadInStateFrom(this);
 
             return part;
         }
 
+        /// <summary>
+        /// Copies the lead-in state that goes with a copied program. Without it a copy of a
+        /// lead-in part reads its rotation from the rebuilt program (zero), and lead-in
+        /// assignment does not know to strip the copied lead-ins before adding new ones.
+        /// </summary>
+        private void CopyLeadInStateFrom(Part source)
+        {
+            HasManualLeadIns = source.HasManualLeadIns;
+            LeadInsLocked = source.LeadInsLocked;
+            CuttingParameters = source.CuttingParameters;
+            preLeadInRotation = source.preLeadInRotation;
+        }
+
         private void EnsureOwnedProgram()
         {
             if (!ownsProgram)

OpenNest.Core/Plate.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using OpenNest.Collections;
@@ -94,18 +94,40 @@ namespace OpenNest
         /// <summary>
         /// Regenerates all cut-off drawings and materializes them as parts.
         /// Existing cut-off parts are removed first, then each cut-off is
-        /// regenerated and added back if it produces any geometry.
+        /// regenerated and put back at the same place in the cut sequence
+        /// (<see cref="Parts"/> order). New cut-offs are added at the end.
         /// </summary>
         public void RegenerateCutOffs(CutOffSettings settings)
         {
-            // Remove existing cut-off parts
+            // Remember each cut-off's place in the cut sequence, so a part drag
+            // or cut-off move doesn't send it to the end of the sequence.
+            var sequence = new Dictionary<CutOff, int>();
+
             for (var i = Parts.Count - 1; i >= 0; i--)
             {
-                if (Parts[i].BaseDrawing.IsCutOff)
+                if (!Parts[i].BaseDrawing.IsCutOff)
+                    continue;
+
+                var cutoff = CutOffs.FirstOrDefault(c => ReferenceEquals(c.Drawing, Parts[i].BaseDrawing));
+                if (cutoff != null)
+                    sequence[cutoff] = i;
+
                 Parts.RemoveAt(i);
             }
 
+            RegenerateCutOffs(settings, sequence);
+        }
+
+        /// <summary>
+        /// Regenerates all cut-off drawings and materializes them as parts, placing
+        /// each cut-off at its index in <paramref name="sequence"/> (its place in
+        /// <see cref="Parts"/> order). Cut-offs missing from it are added at the end.
+        /// Callers must remove existing cut-off parts first.
+        /// </summary>
+        public void RegenerateCutOffs(CutOffSettings settings, IReadOnlyDictionary<CutOff, int> sequence)
+        {
             var cache = BuildPerimeterCache(this);
+            var placed = new List<(int Index, Part Part)>();
 
             // Regenerate and materialize each cut-off
             foreach (var cutoff in CutOffs)
@@ -116,8 +138,17 @@ namespace OpenNest
                     continue;
 
                 var part = new Part(cutoff.Drawing);
+
+                if (sequence != null && sequence.TryGetValue(cutoff, out var index))
+                    placed.Add((index, part));
+                else
                     Parts.Add(part);
             }
+
+            // Lowest index first: each insert then lands on its saved index, because
+            // every part sequenced before it is already in place.
+            foreach (var (index, part) in placed.OrderBy(p => p.Index))
+                Parts.Insert(System.Math.Clamp(index, 0, Parts.Count), part);
         }
 
         /// <summary>
@@ -143,7 +174,13 @@ namespace OpenNest
 
                     if (entities.Count > 0)
                     {
-                        var profile = new Geometry.ShapeProfile(entities);
+                        // Leads are cutting paths in scrap, not boundary edges. Chaining them
+                        // into the outline can make a closed part appear open and replace its
+                        // recesses with a convex hull. Keep the full geometry for the existing
+                        // conservative fallback when the material contour really is open.
+                        var outline = entities.Where(e => e.Layer != SpecialLayers.Leadin &&
+                            e.Layer != SpecialLayers.Leadout).ToList();
+                        var profile = new Geometry.ShapeProfile(outline);
 
                         if (profile.Perimeter.IsClosed())
                         {

OpenNest.Core/PostSettings/PostSettingAttribute.cs

@@ -0,0 +1,56 @@
+using System;
+
+namespace OpenNest.PostSettings
+{
+    /// <summary>
+    /// Places a post-processor config property in a section of the desktop
+    /// settings editor. A config type opts into the sectioned editor by marking
+    /// at least one property; unmarked configs keep the generic PropertyGrid.
+    /// Label and help text come from <c>DisplayName</c> and <c>Description</c>.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+    public sealed class PostSettingAttribute : Attribute
+    {
+        public PostSettingAttribute(string section, int order = 0)
+        {
+            Section = section;
+            Order = order;
+        }
+
+        public string Section { get; }
+
+        public int Order { get; }
+
+        /// <summary>Lower bound for numeric fields; NaN uses the kind's default.</summary>
+        public double Minimum { get; set; } = double.NaN;
+
+        /// <summary>Upper bound for numeric fields; NaN uses the kind's default.</summary>
+        public double Maximum { get; set; } = double.NaN;
+
+        /// <summary>Decimal places for decimal fields; negative uses the default.</summary>
+        public int DecimalPlaces { get; set; } = -1;
+
+        /// <summary>Column header for the key of a name/value table.</summary>
+        public string KeyHeader { get; set; }
+
+        /// <summary>Column header for the value of a name/value table.</summary>
+        public string ValueHeader { get; set; }
+    }
+
+    /// <summary>Declares a settings section's order and description.</summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+    public sealed class PostSettingsSectionAttribute : Attribute
+    {
+        public PostSettingsSectionAttribute(string name, int order)
+        {
+            Name = name;
+            Order = order;
+        }
+
+        public string Name { get; }
+
+        public int Order { get; }
+
+        public string Description { get; set; }
+    }
+}

OpenNest.Core/PostSettings/PostSettingsLayout.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Reflection;
+
+namespace OpenNest.PostSettings
+{
+    public enum PostSettingKind
+    {
+        Text,
+        Integer,
+        Decimal,
+        Boolean,
+        Choice,
+        StringMap,
+    }
+
+    public sealed class PostSettingsField
+    {
+        internal PostSettingsField(
+            PropertyInfo property,
+            PostSettingKind kind,
+            PostSettingAttribute setting
+        )
+        {
+            Property = property;
+            Kind = kind;
+            Label =
+                property.GetCustomAttribute<DisplayNameAttribute>()?.DisplayName
+                ?? property.Name;
+            Description = property.GetCustomAttribute<DescriptionAttribute>()?.Description ?? "";
+
+            var (min, max) = DefaultRange(kind);
+            Minimum = setting != null && !double.IsNaN(setting.Minimum) ? setting.Minimum : min;
+            Maximum = setting != null && !double.IsNaN(setting.Maximum) ? setting.Maximum : max;
+            DecimalPlaces =
+                kind == PostSettingKind.Integer ? 0
+                : setting != null && setting.DecimalPlaces >= 0 ? setting.DecimalPlaces
+                : 3;
+            KeyHeader = setting?.KeyHeader ?? "Name";
+            ValueHeader = setting?.ValueHeader ?? "Value";
+        }
+
+        public PropertyInfo Property { get; }
+
+        public string Name => Property.Name;
+
+        public PostSettingKind Kind { get; }
+
+        public string Label { get; }
+
+        public string Description { get; }
+
+        public double Minimum { get; }
+
+        public double Maximum { get; }
+
+        public int DecimalPlaces { get; }
+
+        public string KeyHeader { get; }
+
+        public string ValueHeader { get; }
+
+        public string[] ChoiceNames =>
+            Kind == PostSettingKind.Choice
+                ? Enum.GetNames(Property.PropertyType)
+                : Array.Empty<string>();
+
+        public object GetValue(object config) => Property.GetValue(config);
+
+        public void SetValue(object config, object value) => Property.SetValue(config, value);
+
+        private static (double, double) DefaultRange(PostSettingKind kind) =>
+            kind == PostSettingKind.Integer ? (int.MinValue, int.MaxValue) : (-1e9, 1e9);
+    }
+
+    public sealed class PostSettingsSection
+    {
+        internal PostSettingsSection(
+            string name,
+            string description,
+            IReadOnlyList<PostSettingsField> fields
+        )
+        {
+            Name = name;
+            Description = description ?? "";
+            Fields = fields;
+        }
+
+        public string Name { get; }
+
+        public string Description { get; }
+
+        public IReadOnlyList<PostSettingsField> Fields { get; }
+    }
+
+    /// <summary>
+    /// Builds the sectioned settings layout for a post-processor config from its
+    /// <see cref="PostSettingAttribute"/> metadata, without any UI dependency.
+    /// </summary>
+    public static class PostSettingsLayout
+    {
+        public const string OtherSection = "Other";
+
+        /// <summary>
+        /// Returns the ordered sections, or null when the config should use the
+        /// generic PropertyGrid: it has no <see cref="PostSettingAttribute"/>,
+        /// or one of its editable properties has a type the editor cannot show.
+        /// Editable properties without the attribute go to the
+        /// <see cref="OtherSection"/> so none become uneditable.
+        /// </summary>
+        public static IReadOnlyList<PostSettingsSection> TryBuild(Type configType)
+        {
+            if (configType == null)
+                return null;
+
+            var properties = configType
+                .GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                .Where(p =>
+                    p.CanRead
+                    && p.GetSetMethod() != null
+                    && p.GetIndexParameters().Length == 0
+                    && p.GetCustomAttribute<BrowsableAttribute>()?.Browsable != false
+                )
+                .OrderBy(p => p.MetadataToken)
+                .ToList();
+
+            if (!properties.Any(p => p.GetCustomAttribute<PostSettingAttribute>() != null))
+                return null;
+
+            var entries = new List<(string Section, int Order, int Index, PostSettingsField Field)>();
+            for (var i = 0; i < properties.Count; i++)
+            {
+                var property = properties[i];
+                var kind = KindOf(property.PropertyType);
+                if (kind == null)
+                    return null;
+
+                var setting = property.GetCustomAttribute<PostSettingAttribute>();
+                var section = string.IsNullOrWhiteSpace(setting?.Section)
+                    ? OtherSection
+                    : setting.Section;
+                entries.Add(
+                    (
+                        section,
+                        setting?.Order ?? int.MaxValue,
+                        i,
+                        new PostSettingsField(property, kind.Value, setting)
+                    )
+                );
+            }
+
+            var declared = configType
+                .GetCustomAttributes<PostSettingsSectionAttribute>()
+                .GroupBy(a => a.Name, StringComparer.Ordinal)
+                .ToDictionary(g => g.Key, g => g.First(), StringComparer.Ordinal);
+
+            return entries
+                .GroupBy(e => e.Section, StringComparer.Ordinal)
+                .Select(g => new
+                {
+                    Name = g.Key,
+                    Declared = declared.TryGetValue(g.Key, out var d) ? d : null,
+                    FirstIndex = g.Min(e => e.Index),
+                    Fields = g.OrderBy(e => e.Order).ThenBy(e => e.Index).Select(e => e.Field).ToList(),
+                })
+                .OrderBy(s => s.Name == OtherSection && s.Declared == null ? 2
+                    : s.Declared != null ? 0
+                    : 1)
+                .ThenBy(s => s.Declared?.Order ?? 0)
+                .ThenBy(s => s.FirstIndex)
+                .Select(s => new PostSettingsSection(s.Name, s.Declared?.Description, s.Fields))
+                .ToList();
+        }
+
+        /// <summary>
+        /// Builds a name/value map from edited table rows using the supplied key
+        /// comparer. Keys and values are trimmed; fully blank rows are skipped.
+        /// Throws <see cref="FormatException"/> naming the 1-based row for a
+        /// missing or duplicate name.
+        /// </summary>
+        public static Dictionary<string, string> BuildMap(
+            IEnumerable<KeyValuePair<string, string>> rows,
+            IEqualityComparer<string> comparer
+        )
+        {
+            var map = new Dictionary<string, string>(comparer ?? StringComparer.Ordinal);
+            var row = 0;
+
+            foreach (var entry in rows ?? Enumerable.Empty<KeyValuePair<string, string>>())
+            {
+                row++;
+                var key = entry.Key?.Trim() ?? "";
+                var value = entry.Value?.Trim() ?? "";
+
+                if (key.Length == 0 && value.Length == 0)
+                    continue;
+                if (key.Length == 0)
+                    throw new FormatException($"Row {row}: a name is required.");
+                if (map.ContainsKey(key))
+                    throw new FormatException($"Row {row}: \"{key}\" is listed more than once.");
+
+                map.Add(key, value);
+            }
+
+            return map;
+        }
+
+        private static PostSettingKind? KindOf(Type type)
+        {
+            if (type == typeof(string))
+                return PostSettingKind.Text;
+            if (type == typeof(int))
+                return PostSettingKind.Integer;
+            if (type == typeof(double))
+                return PostSettingKind.Decimal;
+            if (type == typeof(bool))
+                return PostSettingKind.Boolean;
+            if (type.IsEnum)
+                return PostSettingKind.Choice;
+            if (
+                type == typeof(Dictionary<string, string>)
+                || type == typeof(IDictionary<string, string>)
+            )
+                return PostSettingKind.StringMap;
+
+            return null;
+        }
+    }
+}

OpenNest.Data/EngineSelectionSettings.cs

@@ -0,0 +1,95 @@
+using System.Text.Json;
+
+namespace OpenNest.Data;
+
+/// <summary>
+/// Last-used Auto Nest engine, stored separately from nest/plate defaults.
+/// Loading does not resolve the name: the host must finish plug-in discovery first.
+/// </summary>
+public sealed class EngineSelectionSettings
+{
+    public const string DefaultEngineName = "Default";
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+    };
+
+    public string EngineName { get; set; } = DefaultEngineName;
+
+    /// <summary>%APPDATA%\OpenNest\engine-selection.json.</summary>
+    public static string DefaultPath => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+        "OpenNest", "engine-selection.json");
+
+    /// <summary>Missing, unreadable or corrupt settings safely use Default without writing.</summary>
+    public static EngineSelectionSettings Load(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
+            return new();
+
+        try
+        {
+            var settings = JsonSerializer.Deserialize<EngineSelectionSettings>(
+                File.ReadAllText(path), JsonOptions) ?? new();
+            settings.EngineName = NormalizeName(settings.EngineName);
+            return settings;
+        }
+        catch (Exception ex) when (ex is JsonException or IOException or UnauthorizedAccessException)
+        {
+            return new();
+        }
+    }
+
+    /// <summary>
+    /// Resolves against the host's selectable engines AFTER plug-in loading. A missing engine
+    /// returns Default plus a status-bar warning, without replacing the saved preference.
+    /// Names use registry casing so desktop combo-box selection remains exact.
+    /// </summary>
+    public string Resolve(IEnumerable<string> availableEngineNames, out string? statusMessage)
+    {
+        ArgumentNullException.ThrowIfNull(availableEngineNames);
+        var requestedName = NormalizeName(EngineName);
+        var registeredName = availableEngineNames.FirstOrDefault(
+            name => string.Equals(name, requestedName, StringComparison.OrdinalIgnoreCase));
+        if (registeredName is not null)
+        {
+            statusMessage = null;
+            return registeredName;
+        }
+
+        statusMessage = $"Saved Auto Nest engine '{requestedName}' is unavailable. Using Default.";
+        return DefaultEngineName;
+    }
+
+    /// <summary>
+    /// Writes camelCase JSON, creating the parent directory and retrying IO collisions as
+    /// LocalJsonProvider does. The host handles a persistent write failure.
+    /// </summary>
+    public void Save(string path)
+    {
+        var json = JsonSerializer.Serialize(
+            new EngineSelectionSettings { EngineName = NormalizeName(EngineName) }, JsonOptions);
+        var directory = Path.GetDirectoryName(Path.GetFullPath(path));
+
+        for (var attempt = 0; attempt < 3; attempt++)
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(directory))
+                    Directory.CreateDirectory(directory);
+                File.WriteAllText(path, json);
+                return;
+            }
+            catch (IOException) when (attempt < 2)
+            {
+                Thread.Sleep(100);
+            }
+        }
+    }
+
+    private static string NormalizeName(string? name) =>
+        string.IsNullOrWhiteSpace(name) ? DefaultEngineName : name.Trim();
+}

OpenNest.Data/INestRepository.cs

@@ -0,0 +1,31 @@
+namespace OpenNest.Data;
+
+/// <summary>
+/// Storage backend for saved nests. <see cref="RemoteNestRepository"/> talks to the
+/// central nest server; File mode in the desktop app keeps using SaveFileDialog and
+/// does not go through this interface.
+/// </summary>
+public interface INestRepository
+{
+    /// <summary>All stored nests, newest saved first.</summary>
+    Task<IReadOnlyList<NestRecord>> ListAsync(CancellationToken cancellationToken = default);
+
+    Task<NestRecord?> GetMetadataAsync(Guid id, CancellationToken cancellationToken = default);
+
+    /// <summary>Downloaded .nest archive bytes, or null when the id does not exist.</summary>
+    Task<byte[]?> GetFileAsync(Guid id, CancellationToken cancellationToken = default);
+
+    /// <summary>Stores a new nest; returns the server-assigned record.</summary>
+    Task<NestRecord> UploadAsync(
+        byte[] nestFile, NestRecord record, CancellationToken cancellationToken = default);
+
+    /// <summary>Replaces the archive and metadata of an existing id, keeping the id.</summary>
+    Task<NestRecord> UpdateFileAsync(
+        Guid id, byte[] nestFile, NestRecord record, CancellationToken cancellationToken = default);
+
+    /// <summary>Replaces metadata only (status, made-by, comments...), leaving the archive.</summary>
+    Task<NestRecord> UpdateMetadataAsync(
+        Guid id, NestRecord record, CancellationToken cancellationToken = default);
+
+    Task DeleteAsync(Guid id, CancellationToken cancellationToken = default);
+}

OpenNest.Data/NestDefaults.cs

@@ -0,0 +1,270 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using OpenNest.Geometry;
+
+namespace OpenNest.Data;
+
+/// <summary>Outcome of <see cref="NestDefaults.Load(string, out NestDefaultsStatus)"/>.</summary>
+public enum NestDefaultsStatus
+{
+    /// <summary>Defaults were read from the file (invalid fields still fall back individually).</summary>
+    Ok,
+
+    /// <summary>No file exists at the path; built-in fallback values were used.</summary>
+    Missing,
+
+    /// <summary>The file exists but could not be read or parsed; fallback values were used.</summary>
+    Invalid,
+}
+
+/// <summary>
+/// Plate/nest defaults persisted to a single JSON file
+/// (by default %APPDATA%\OpenNest\defaults.json), replacing the
+/// .nstdot nest-template mechanism. Loading never throws: a missing,
+/// corrupt, or partially valid file degrades field-by-field to
+/// <see cref="Fallback"/> values so creating a new nest is never blocked.
+/// </summary>
+public sealed class NestDefaults
+{
+    public const int CurrentVersion = 1;
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) },
+    };
+
+    public Units Units { get; set; } = Units.Inches;
+
+    public Size Size { get; set; } = new(100, 100);
+
+    public int Quadrant { get; set; } = 1;
+
+    public double PartSpacing { get; set; } = 1;
+
+    public Spacing EdgeSpacing { get; set; } = new(1, 1, 1, 1);
+
+    /// <summary>
+    /// The built-in defaults used when no file exists and for every field
+    /// that is missing or invalid. Matches the historical
+    /// MainForm.CreateDefaultNest values (units default to Inches; callers
+    /// may override from their own settings).
+    /// </summary>
+    public static NestDefaults Fallback => new();
+
+    /// <summary>%APPDATA%\OpenNest\defaults.json.</summary>
+    public static string DefaultPath =>
+        Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            "OpenNest",
+            "defaults.json"
+        );
+
+    /// <summary>
+    /// Loads defaults from <paramref name="path"/>, falling back field by
+    /// field for a missing file, invalid JSON, or invalid values.
+    /// </summary>
+    public static NestDefaults Load(string path) => Load(path, out _);
+
+    /// <summary>
+    /// Loads defaults and reports whether the file was missing, loaded, or
+    /// present but unreadable/invalid, so callers can warn about a corrupt
+    /// file while still returning usable values.
+    /// </summary>
+    public static NestDefaults Load(string path, out NestDefaultsStatus status)
+    {
+        var defaults = Fallback;
+        if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
+        {
+            status = NestDefaultsStatus.Missing;
+            return defaults;
+        }
+
+        NestDefaultsDto? dto;
+        try
+        {
+            var json = File.ReadAllText(path);
+            dto = JsonSerializer.Deserialize<NestDefaultsDto>(json, JsonOptions);
+        }
+        catch (JsonException)
+        {
+            status = NestDefaultsStatus.Invalid;
+            return defaults;
+        }
+        catch (IOException)
+        {
+            status = NestDefaultsStatus.Invalid;
+            return defaults;
+        }
+
+        if (dto is null)
+        {
+            status = NestDefaultsStatus.Invalid;
+            return defaults;
+        }
+
+        status = NestDefaultsStatus.Ok;
+
+        if (
+            dto.Units is not null
+            && Enum.TryParse<Units>(dto.Units, ignoreCase: true, out var units)
+        )
+            defaults.Units = units;
+
+        if (
+            dto.Size?.Width is { } width
+            && dto.Size.Length is { } length
+            && IsValidSize(width, length)
+        )
+            defaults.Size = new Size(width, length);
+
+        if (dto.Quadrant is { } quadrant && quadrant is >= 1 and <= 4)
+            defaults.Quadrant = quadrant;
+
+        if (dto.PartSpacing is { } partSpacing && IsValidSpacing(partSpacing))
+            defaults.PartSpacing = partSpacing;
+
+        if (
+            dto.EdgeSpacing?.Left is { } left
+            && dto.EdgeSpacing.Bottom is { } bottom
+            && dto.EdgeSpacing.Right is { } right
+            && dto.EdgeSpacing.Top is { } top
+            && IsValidSpacing(left)
+            && IsValidSpacing(bottom)
+            && IsValidSpacing(right)
+            && IsValidSpacing(top)
+        )
+            defaults.EdgeSpacing = new Spacing(left, bottom, right, top);
+
+        return defaults;
+    }
+
+    /// <summary>
+    /// Captures the current units and plate defaults from a nest.
+    /// </summary>
+    public static NestDefaults FromNest(Nest nest)
+    {
+        ArgumentNullException.ThrowIfNull(nest);
+        var plate = nest.PlateDefaults;
+        return new NestDefaults
+        {
+            Units = nest.Units,
+            Size = plate.Size,
+            Quadrant = plate.Quadrant,
+            PartSpacing = plate.PartSpacing,
+            EdgeSpacing = plate.EdgeSpacing,
+        };
+    }
+
+    /// <summary>
+    /// Captures defaults from an existing plate (a copy of its size,
+    /// quadrant, and spacing), e.g. the active plate in the desktop app.
+    /// </summary>
+    public static NestDefaults FromPlate(Units units, Plate plate)
+    {
+        ArgumentNullException.ThrowIfNull(plate);
+        return new NestDefaults
+        {
+            Units = units,
+            Size = plate.Size,
+            Quadrant = plate.Quadrant,
+            PartSpacing = plate.PartSpacing,
+            EdgeSpacing = plate.EdgeSpacing,
+        };
+    }
+
+    public void ApplyTo(Nest nest)
+    {
+        ArgumentNullException.ThrowIfNull(nest);
+        nest.Units = Units;
+        var plate = nest.PlateDefaults;
+        plate.Size = Size;
+        plate.Quadrant = Quadrant;
+        plate.PartSpacing = PartSpacing;
+        plate.EdgeSpacing = EdgeSpacing;
+    }
+
+    /// <summary>
+    /// Writes the file (creating the parent directory), retrying briefly on
+    /// IO collisions the same way <see cref="LocalJsonProvider"/> does.
+    /// </summary>
+    public void Save(string path, int maxRetries = 3)
+    {
+        var dto = new NestDefaultsDto
+        {
+            Version = CurrentVersion,
+            Units = Units.ToString().ToLowerInvariant(),
+            Size = new SizeDto { Width = Size.Width, Length = Size.Length },
+            Quadrant = Quadrant,
+            PartSpacing = PartSpacing,
+            EdgeSpacing = new SpacingDto
+            {
+                Left = EdgeSpacing.Left,
+                Bottom = EdgeSpacing.Bottom,
+                Right = EdgeSpacing.Right,
+                Top = EdgeSpacing.Top,
+            },
+        };
+
+        var json = JsonSerializer.Serialize(dto, JsonOptions);
+
+        var directory = Path.GetDirectoryName(Path.GetFullPath(path));
+        if (!string.IsNullOrEmpty(directory))
+            Directory.CreateDirectory(directory);
+
+        for (var attempt = 0; attempt < maxRetries; attempt++)
+        {
+            try
+            {
+                File.WriteAllText(path, json);
+                return;
+            }
+            catch (IOException) when (attempt < maxRetries - 1)
+            {
+                Thread.Sleep(100);
+            }
+        }
+    }
+
+    private static bool IsValidSize(double width, double length) =>
+        !double.IsNaN(width)
+            && !double.IsNaN(length)
+            && !double.IsInfinity(width)
+            && !double.IsInfinity(length)
+            && width > 0
+            && length > 0;
+
+    private static bool IsValidSpacing(double value) =>
+        !double.IsNaN(value) && !double.IsInfinity(value) && value >= 0;
+
+    /// <summary>
+    /// Wire format. Every field is nullable so a partial file merges over
+    /// the fallback field by field; unknown fields (including a future
+    /// higher <c>version</c>) are ignored rather than rejected.
+    /// </summary>
+    private sealed record NestDefaultsDto
+    {
+        public int? Version { get; init; } = CurrentVersion;
+        public string? Units { get; init; }
+        public SizeDto? Size { get; init; }
+        public int? Quadrant { get; init; }
+        public double? PartSpacing { get; init; }
+        public SpacingDto? EdgeSpacing { get; init; }
+    }
+
+    private sealed record SizeDto
+    {
+        public double? Width { get; init; }
+        public double? Length { get; init; }
+    }
+
+    private sealed record SpacingDto
+    {
+        public double? Left { get; init; }
+        public double? Bottom { get; init; }
+        public double? Right { get; init; }
+        public double? Top { get; init; }
+    }
+}

OpenNest.Data/NestRecord.cs

@@ -0,0 +1,42 @@
+using OpenNest;
+
+namespace OpenNest.Data;
+
+/// <summary>
+/// Server-side metadata for one saved nest. The .nest archive itself is stored
+/// alongside; this record is what lists, filters and status tracking read.
+/// Counts are captured by the client at save time.
+/// </summary>
+public sealed class NestRecord
+{
+    public Guid Id { get; set; }
+
+    public string Name { get; set; } = "";
+
+    public string Customer { get; set; } = "";
+
+    public DateTime DateCreated { get; set; }
+
+    public DateTime DateModified { get; set; }
+
+    public string Material { get; set; } = "";
+
+    public double Thickness { get; set; }
+
+    /// <summary>quote | toBeCut | hasBeenCut (camelCase on the wire, case-insensitive readers).</summary>
+    public NestStatus Status { get; set; } = NestStatus.Quote;
+
+    public int PlateCount { get; set; }
+
+    public int PartCount { get; set; }
+
+    public string Comments { get; set; } = "";
+
+    public string MadeBy { get; set; } = "";
+
+    /// <summary>Size of the stored .nest archive in bytes.</summary>
+    public long FileSize { get; set; }
+
+    /// <summary>When the server last stored the nest contents or metadata.</summary>
+    public DateTime SavedAt { get; set; }
+}

OpenNest.Data/NestRecordFactory.cs

@@ -0,0 +1,45 @@
+using System.Linq;
+
+namespace OpenNest.Data;
+
+/// <summary>
+/// Builds the shareable <see cref="NestRecord"/> metadata from a live <see cref="Nest"/>.
+/// Counts are computed here (not carried on <see cref="Nest"/> itself) so every caller
+/// that saves to the nest server gets the same definition of "plate" and "part" counts.
+/// </summary>
+public static class NestRecordFactory
+{
+    /// <summary>
+    /// Builds a record for uploading <paramref name="nest"/>. <paramref name="id"/> is the
+    /// client-tracked id: <see cref="System.Guid.Empty"/> for a first save (the server
+    /// assigns one), or the previously returned id to update an existing record.
+    /// <paramref name="fileSize"/> is the size of the serialized .nest archive being
+    /// uploaded alongside this record; the server also recomputes it independently.
+    /// </summary>
+    public static NestRecord FromNest(Nest nest, System.Guid id, long fileSize)
+    {
+        ArgumentNullException.ThrowIfNull(nest);
+
+        return new NestRecord
+        {
+            Id = id,
+            Name = nest.Name ?? "",
+            Customer = nest.Customer ?? "",
+            DateCreated = nest.DateCreated,
+            DateModified = nest.DateLastModified,
+            Material = nest.Material?.Name ?? "",
+            Thickness = nest.Thickness,
+            Status = nest.Status,
+            PlateCount = nest.Plates.Count,
+            PartCount = nest.Plates.Sum(CountNonCutoffParts),
+            // Nest has no separate "comments" field; Notes is the closest analog
+            // shown in the nest info dialog, so it round-trips as Comments here.
+            Comments = nest.Notes ?? "",
+            MadeBy = nest.MadeBy ?? "",
+            FileSize = fileSize,
+        };
+    }
+
+    private static int CountNonCutoffParts(Plate plate) =>
+        plate.Parts.Count(part => !part.BaseDrawing.IsCutOff);
+}

OpenNest.Data/NestSaveSession.cs

@@ -0,0 +1,46 @@
+namespace OpenNest.Data;
+
+/// <summary>
+/// Tracks a document's database identity, bound to a particular server address.
+/// A failed upload leaves that identity untouched. Switching servers creates a new
+/// record rather than accidentally updating an unrelated record with the same id.
+/// </summary>
+public sealed class NestSaveSession
+{
+    public Guid RemoteId { get; private set; }
+    public string ServerUrl { get; private set; } = "";
+
+    public void Bind(Guid id, string serverUrl)
+    {
+        if (id == Guid.Empty)
+            throw new ArgumentException("A saved nest needs a non-empty id.", nameof(id));
+        RemoteId = id;
+        ServerUrl = Normalize(serverUrl);
+    }
+
+    public async Task<NestRecord> SaveAsync(
+        INestRepository repository, string serverUrl, Nest nest, byte[] archive,
+        bool saveCopy = false, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(repository);
+        ArgumentNullException.ThrowIfNull(nest);
+        ArgumentNullException.ThrowIfNull(archive);
+
+        var normalizedUrl = Normalize(serverUrl);
+        if (normalizedUrl.Length == 0)
+            throw new ArgumentException("A database server URL is required.", nameof(serverUrl));
+
+        var id = !saveCopy && ServerUrl == normalizedUrl ? RemoteId : Guid.Empty;
+        var record = NestRecordFactory.FromNest(nest, id, archive.LongLength);
+        var saved = id == Guid.Empty
+            ? await repository.UploadAsync(archive, record, cancellationToken)
+            : await repository.UpdateFileAsync(id, archive, record, cancellationToken);
+        if (saved.Id == Guid.Empty || (id != Guid.Empty && saved.Id != id))
+            throw new InvalidDataException("Server returned an invalid nest id.");
+
+        Bind(saved.Id, normalizedUrl);
+        return saved;
+    }
+
+    private static string Normalize(string? url) => (url ?? "").Trim().TrimEnd('/');
+}

OpenNest.Data/NestStorageSettings.cs

@@ -0,0 +1,83 @@
+using System.Text.Json;
+
+namespace OpenNest.Data;
+
+/// <summary>Where the desktop app persists nests: local .nest files or the shared nest server.</summary>
+public enum NestStorageMode
+{
+    File,
+    Database,
+}
+
+/// <summary>
+/// Storage-mode toggle and nest-server address, stored at %APPDATA%\OpenNest\storage.json.
+/// Loading never throws; a missing or corrupt file means File mode so existing installs
+/// keep the original behavior until the operator opts in.
+/// </summary>
+public sealed class NestStorageSettings
+{
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+    };
+
+    public NestStorageMode Mode { get; set; } = NestStorageMode.File;
+
+    /// <summary>Base URL of the nest server, e.g. http://barge.lan:8090. No trailing slash required.</summary>
+    public string ServerUrl { get; set; } = "";
+
+    /// <summary>True when Database mode is active and a server URL is configured.</summary>
+    public bool IsDatabaseMode =>
+        Mode == NestStorageMode.Database && !string.IsNullOrWhiteSpace(ServerUrl);
+
+    /// <summary>%APPDATA%\OpenNest\storage.json.</summary>
+    public static string DefaultPath => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+        "OpenNest", "storage.json");
+
+    public static NestStorageSettings Load(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
+            return new();
+
+        try
+        {
+            var settings = JsonSerializer.Deserialize<NestStorageSettings>(
+                File.ReadAllText(path), JsonOptions) ?? new();
+            settings.ServerUrl = NormalizeUrl(settings.ServerUrl);
+            return settings;
+        }
+        catch (Exception ex) when (ex is JsonException or IOException or UnauthorizedAccessException)
+        {
+            return new();
+        }
+    }
+
+    /// <summary>Writes camelCase JSON, creating the parent directory and retrying IO collisions.</summary>
+    public void Save(string path)
+    {
+        var json = JsonSerializer.Serialize(
+            new NestStorageSettings { Mode = Mode, ServerUrl = NormalizeUrl(ServerUrl) },
+            JsonOptions);
+        var directory = Path.GetDirectoryName(Path.GetFullPath(path));
+
+        for (var attempt = 0; attempt < 3; attempt++)
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(directory))
+                    Directory.CreateDirectory(directory);
+                File.WriteAllText(path, json);
+                return;
+            }
+            catch (IOException) when (attempt < 2)
+            {
+                Thread.Sleep(100);
+            }
+        }
+    }
+
+    private static string NormalizeUrl(string? url) => (url ?? "").Trim().TrimEnd('/');
+}

OpenNest.Data/RemoteNestRepository.cs

@@ -0,0 +1,159 @@
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace OpenNest.Data;
+
+/// <summary>
+/// Talks to the central OpenNest nest server over HTTP. Uploads are multipart:
+/// a "metadata" JSON part and a "file" part holding the .nest archive.
+/// Connection and HTTP failures surface as HttpRequestException/IOException to the caller.
+/// </summary>
+public sealed class RemoteNestRepository : INestRepository, IDisposable
+{
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) },
+    };
+
+    private readonly HttpClient _httpClient;
+    private readonly bool _ownsClient;
+    private readonly Uri _baseUri;
+
+    public RemoteNestRepository(string baseUrl)
+        : this(new HttpClient(), baseUrl)
+    {
+        _ownsClient = true;
+    }
+
+    /// <summary>For tests and hosts that pool HttpClient instances.</summary>
+    public RemoteNestRepository(HttpClient httpClient, string baseUrl)
+    {
+        _httpClient = httpClient;
+        _ownsClient = false;
+        var url = (baseUrl ?? "").Trim().TrimEnd('/');
+        if (!Uri.TryCreate(url, UriKind.Absolute, out var baseUri)
+            || (baseUri.Scheme != Uri.UriSchemeHttp && baseUri.Scheme != Uri.UriSchemeHttps))
+        {
+            throw new ArgumentException($"Invalid nest server URL: '{baseUrl}'", nameof(baseUrl));
+        }
+        // Keep the trailing slash so relative combines replace no path segment.
+        _baseUri = new Uri(baseUri.AbsoluteUri.TrimEnd('/') + "/");
+    }
+
+    private Uri Url(string relative) => new(_baseUri, relative);
+
+    public async Task<IReadOnlyList<NestRecord>> ListAsync(CancellationToken cancellationToken = default)
+    {
+        using var response = await _httpClient.GetAsync(Url("api/nests"), cancellationToken);
+        await EnsureSuccess(response, "list nests", cancellationToken);
+        var items = await response.Content
+            .ReadFromJsonAsync<List<NestRecord>>(JsonOptions, cancellationToken);
+        return items ?? new List<NestRecord>();
+    }
+
+    public async Task<NestRecord?> GetMetadataAsync(Guid id, CancellationToken cancellationToken = default)
+    {
+        using var response = await _httpClient.GetAsync(Url($"api/nests/{id}"), cancellationToken);
+        if (response.StatusCode == HttpStatusCode.NotFound)
+            return null;
+        await EnsureSuccess(response, $"get nest {id}", cancellationToken);
+        return await response.Content.ReadFromJsonAsync<NestRecord>(JsonOptions, cancellationToken);
+    }
+
+    public async Task<byte[]?> GetFileAsync(Guid id, CancellationToken cancellationToken = default)
+    {
+        using var response = await _httpClient.GetAsync(Url($"api/nests/{id}/file"), cancellationToken);
+        if (response.StatusCode == HttpStatusCode.NotFound)
+            return null;
+        await EnsureSuccess(response, $"download nest {id}", cancellationToken);
+        return await response.Content.ReadAsByteArrayAsync(cancellationToken);
+    }
+
+    public async Task<NestRecord> UploadAsync(
+        byte[] nestFile, NestRecord record, CancellationToken cancellationToken = default)
+    {
+        using var content = BuildMultipart(nestFile, record);
+        using var response = await _httpClient.PostAsync(Url("api/nests"), content, cancellationToken);
+        await EnsureSuccess(response, $"upload nest '{record.Name}'", cancellationToken);
+        return await ReadRecord(response, cancellationToken);
+    }
+
+    public async Task<NestRecord> UpdateFileAsync(
+        Guid id, byte[] nestFile, NestRecord record, CancellationToken cancellationToken = default)
+    {
+        using var content = BuildMultipart(nestFile, record);
+        using var response = await _httpClient.PutAsync(Url($"api/nests/{id}/file"), content, cancellationToken);
+        await EnsureSuccess(response, $"update nest {id}", cancellationToken);
+        return await ReadRecord(response, cancellationToken);
+    }
+
+    public async Task<NestRecord> UpdateMetadataAsync(
+        Guid id, NestRecord record, CancellationToken cancellationToken = default)
+    {
+        using var content = new StringContent(
+            JsonSerializer.Serialize(record, JsonOptions), Encoding.UTF8, "application/json");
+        using var response = await _httpClient.PutAsync(Url($"api/nests/{id}/metadata"), content, cancellationToken);
+        await EnsureSuccess(response, $"update nest metadata {id}", cancellationToken);
+        return await ReadRecord(response, cancellationToken);
+    }
+
+    public async Task DeleteAsync(Guid id, CancellationToken cancellationToken = default)
+    {
+        using var response = await _httpClient.DeleteAsync(Url($"api/nests/{id}"), cancellationToken);
+        await EnsureSuccess(response, $"delete nest {id}", cancellationToken);
+    }
+
+    public void Dispose()
+    {
+        if (_ownsClient)
+            _httpClient.Dispose();
+    }
+
+    private static MultipartFormDataContent BuildMultipart(byte[] nestFile, NestRecord record)
+    {
+        var content = new MultipartFormDataContent();
+        var metadata = new StringContent(
+            JsonSerializer.Serialize(record, JsonOptions), Encoding.UTF8, "application/json");
+        content.Add(metadata, "metadata");
+        var file = new ByteArrayContent(nestFile);
+        file.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
+        content.Add(file, "file", record.Name.Length > 0 ? $"{record.Name}.nest" : "nest.nest");
+        return content;
+    }
+
+    private static async Task<NestRecord> ReadRecord(
+        HttpResponseMessage response, CancellationToken cancellationToken)
+    {
+        var record = await response.Content.ReadFromJsonAsync<NestRecord>(JsonOptions, cancellationToken);
+        return record ?? throw new IOException("Nest server returned an empty record.");
+    }
+
+    private static async Task EnsureSuccess(
+        HttpResponseMessage response, string action, CancellationToken cancellationToken)
+    {
+        if (response.IsSuccessStatusCode)
+            return;
+
+        var detail = "";
+        try
+        {
+            detail = await response.Content.ReadAsStringAsync(cancellationToken);
+        }
+        catch (Exception ex) when (ex is IOException or InvalidOperationException)
+        {
+            // The status code is the useful part; the body is best-effort.
+        }
+
+        if (detail.Length > 200)
+            detail = detail[..200] + "…";
+        throw new IOException(
+            $"Could not {action} on the nest server: HTTP {(int)response.StatusCode} {response.ReasonPhrase}. {detail}".TrimEnd());
+    }
+}

OpenNest.Engine.Tests/Fill/ExpanderTests.cs

@@ -0,0 +1,347 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using OpenNest.CNC;
+using OpenNest.Engine.Fill;
+using OpenNest.Geometry;
+using Xunit;
+
+namespace OpenNest.Engine.Tests.Fill;
+
+/// <summary>
+/// PlateView spacing expander: grows part-to-part spacing with the work area
+/// and non-selected parts as hard boundaries.
+/// </summary>
+public class ExpanderTests
+{
+    private static Program Rectangle(double width = 4, double length = 4)
+    {
+        var program = new Program();
+        program.MoveTo(0, 0);
+        program.LineTo(width, 0);
+        program.LineTo(width, length);
+        program.LineTo(0, length);
+        program.LineTo(0, 0);
+        return program;
+    }
+
+    private static Part AddSquare(Plate plate, double x, double y, double size = 4)
+    {
+        var part = new Part(new Drawing($"sq{plate.Parts.Count}", Rectangle(size, size)), new Vector(x, y));
+        plate.Parts.Add(part);
+        return part;
+    }
+
+    private static Plate MakePlate(double lengthX, double widthY, double edge = 0.5)
+    {
+        var plate = new Plate(new Size(widthY, lengthX));
+        plate.EdgeSpacing = new Spacing(edge, edge);
+        return plate;
+    }
+
+    /// <summary>Independent clearance oracle: naive vertex/segment min distance over raw part lines.</summary>
+    private static double BruteClearance(Part a, Part b)
+    {
+        var linesA = PartGeometry.GetPartLines(a);
+        var linesB = PartGeometry.GetPartLines(b);
+
+        double min = double.MaxValue;
+        foreach (var la in linesA)
+            foreach (var lb in linesB)
+            {
+                min = System.Math.Min(min, PointSegment(a, la.StartPoint, lb));
+                min = System.Math.Min(min, PointSegment(a, la.EndPoint, lb));
+                min = System.Math.Min(min, PointSegment(b, lb.StartPoint, la));
+                min = System.Math.Min(min, PointSegment(b, lb.EndPoint, la));
+            }
+        return min;
+    }
+
+    private static double PointSegment(Part owner, Vector pt, Line seg)
+    {
+        var d = seg.EndPoint - seg.StartPoint;
+        var len2 = d.DotProduct(d);
+        var t = len2 <= 1e-12 ? 0 : System.Math.Clamp((pt - seg.StartPoint).DotProduct(d) / len2, 0, 1);
+        return pt.DistanceTo(seg.StartPoint + d * t);
+    }
+
+    private static void AssertNoOverlaps(Plate plate)
+    {
+        for (var i = 0; i < plate.Parts.Count; i++)
+            for (var j = i + 1; j < plate.Parts.Count; j++)
+                Assert.False(
+                    plate.Parts[i].Intersects(plate.Parts[j], out _),
+                    $"{plate.Parts[i].BaseDrawing.Name} overlaps {plate.Parts[j].BaseDrawing.Name}"
+                );
+    }
+
+    [Fact]
+    public void Expand_TwoSquares_GrowUntilEdgeFloor_AndAnchorStaysPut()
+    {
+        var plate = MakePlate(24, 24);
+        var a = AddSquare(plate, 6, 10);
+        var b = AddSquare(plate, 14, 10);
+
+        var result = Expander.Expand(new List<Part> { a, b }, plate);
+
+        // Max gap: B flush against the right edge floor (23.5): 23.5 - 14 - 4 + gap base...
+        // A stays (anchor); B slides to x=19.5 -> gap 9.5.
+        Assert.Equal(6, a.Location.X, 6);
+        Assert.Equal(10, a.Location.Y, 6);
+        Assert.Equal(9.5, b.Location.X - (a.Location.X + 4), 1);
+        Assert.True(result.AchievedSpacing >= 9.4, $"achieved {result.AchievedSpacing}");
+        Assert.True(result.AchievedSpacing <= 9.6, $"achieved {result.AchievedSpacing}");
+        AssertNoOverlaps(plate);
+        Assert.True(b.BoundingBox.Right <= 23.5 + 1e-6);
+    }
+
+    [Fact]
+    public void Expand_SandwichedBetweenWalls_ConvergesOnlyToInitialGaps_AndKeepsWalls()
+    {
+        var plate = MakePlate(26, 10, edge: 0.0);
+        var wallL = AddSquare(plate, 0, 3);
+        var wallR = AddSquare(plate, 18, 3);
+        var a = AddSquare(plate, 6, 3);
+        var b = AddSquare(plate, 12, 3);
+
+        var result = Expander.Expand(new List<Part> { a, b }, plate);
+
+        // Every gap starts at exactly 2.0; straight separation moves cannot open
+        // the row (opening one gap costs another), so the run stays at ~2.0.
+        Assert.Equal(0, wallL.Location.X, 6);
+        Assert.Equal(18, wallR.Location.X, 6);
+        Assert.True(
+            result.AchievedSpacing >= 1.9 && result.AchievedSpacing <= 2.05,
+            $"achieved {result.AchievedSpacing}"
+        );
+        AssertNoOverlaps(plate);
+    }
+
+    [Fact]
+    public void Expand_OverlappingPair_SeparatesAndClearsOverlap()
+    {
+        var plate = MakePlate(30, 12);
+        var a = AddSquare(plate, 5, 4);
+        var b = AddSquare(plate, 7, 4); // 2.0 overlap in X
+
+        var result = Expander.Expand(new List<Part> { a, b }, plate, new Expander.Options
+        {
+            InitialStep = 0.5,
+            MaxSpacing = 3,
+        });
+
+        Assert.False(a.Intersects(b, out _));
+        var gap = b.Location.X - (a.Location.X + 4);
+        Assert.True(gap >= 2.99, $"gap {gap}");
+        Assert.True(result.AchievedSpacing >= 2.9);
+        AssertNoOverlaps(plate);
+    }
+
+    [Fact]
+    public void Separate_PinnedPart_ReportsViolationsWithoutOverlap()
+    {
+        var plate = MakePlate(20, 20, edge: 0.0);
+        var pinned = AddSquare(plate, 8, 8);
+        // Walls 0.2 clear on all four sides.
+        var left = AddSquare(plate, 3.8, 8);
+        var right = AddSquare(plate, 12.2, 8);
+        var bottom = AddSquare(plate, 8, 3.8);
+        var top = AddSquare(plate, 8, 12.2);
+
+        var (converged, positions, violations) = Expander.Separate(
+            new List<Part> { pinned },
+            plate,
+            spacing: 1.0
+        );
+
+        Assert.False(converged);
+        Assert.NotEmpty(violations);
+        // The pinned part may slide into the walls but never through them.
+        AssertNoOverlaps(plate);
+        Assert.Equal(3.8, left.Location.X, 6);
+        Assert.Equal(12.2, right.Location.X, 6);
+        Assert.Equal(3.8, bottom.Location.Y, 6);
+        Assert.Equal(12.2, top.Location.Y, 6);
+    }
+
+    [Fact]
+    public void Expand_CancelledBeforeRun_LeavesEverythingInPlace()
+    {
+        var plate = MakePlate(24, 24);
+        var a = AddSquare(plate, 6, 10);
+        var b = AddSquare(plate, 14, 10);
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+
+        var result = Expander.Expand(
+            new List<Part> { a, b },
+            plate,
+            token: cts.Token
+        );
+
+        Assert.True(result.Cancelled);
+        Assert.Equal(6, a.Location.X, 6);
+        Assert.Equal(14, b.Location.X, 6);
+    }
+
+    [Fact]
+    public void Expand_ThreeInRow_FirstSelectedNeverMoves_AndOracleConfirmsSpacing()
+    {
+        var plate = MakePlate(60, 14);
+        var a = AddSquare(plate, 5, 5);
+        var b = AddSquare(plate, 10, 5);
+        var c = AddSquare(plate, 15, 5);
+
+        var result = Expander.Expand(
+            new List<Part> { a, b, c },
+            plate,
+            new Expander.Options { MaxSpacing = 8 }
+        );
+
+        Assert.Equal(5, a.Location.X, 6); // anchor: never the later index of any pair
+        Assert.True(result.AchievedSpacing >= 7.9);
+
+        // Independent oracle: every pair clears the reported spacing.
+        var parts = new List<Part> { a, b, c };
+        for (var i = 0; i < parts.Count; i++)
+            for (var j = i + 1; j < parts.Count; j++)
+            {
+                var clearance = BruteClearance(parts[i], parts[j]);
+                Assert.True(
+                    clearance >= result.AchievedSpacing - 0.01,
+                    $"{parts[i].BaseDrawing.Name}/{parts[j].BaseDrawing.Name}: oracle {clearance} < reported {result.AchievedSpacing}"
+                );
+            }
+        AssertNoOverlaps(plate);
+    }
+
+    private static Program RectangleWithHole(
+        double width,
+        double length,
+        double hx,
+        double hy,
+        double hw,
+        double hh
+    )
+    {
+        var program = Rectangle(width, length);
+        program.MoveTo(hx, hy);
+        program.LineTo(hx + hw, hy);
+        program.LineTo(hx + hw, hy + hh);
+        program.LineTo(hx, hy + hh);
+        program.LineTo(hx, hy);
+        return program;
+    }
+
+    /// <summary>
+    /// Hole-subtracting overlap check matching NestValidator semantics (a part in
+    /// a cutout is legal). Part.Intersects is perimeter-only, so it cannot
+    /// certify part-in-cutout layouts.
+    /// </summary>
+    private static bool MateriallyOverlaps(Part a, Part b)
+    {
+        var (outerA, holesA) = Rings(a);
+        var (outerB, holesB) = Rings(b);
+        return Collision.HasOverlap(outerA, outerB, holesA, holesB);
+    }
+
+    private static (Polygon Outer, List<Polygon> Holes) Rings(Part part)
+    {
+        var entities = OpenNest.Converters.ConvertProgram
+            .ToGeometry(part.Program)
+            .Where(e => SpecialLayers.IsMaterial(e.Layer))
+            .ToList();
+        var profile = new ShapeProfile(entities);
+
+        var outer = profile.Perimeter.ToPolygonWithTolerance(0.001);
+        outer.Offset(part.Location);
+
+        var holes = new List<Polygon>();
+        foreach (var cutout in profile.Cutouts)
+        {
+            var hole = cutout.ToPolygonWithTolerance(0.001);
+            hole.Offset(part.Location);
+            holes.Add(hole);
+        }
+
+        return (outer, holes.Count == 0 ? null : holes);
+    }
+
+    [Fact]
+    public void Expand_PartInsideCutout_KeepsLegalAndClearsHoleWalls()
+    {
+        var plate = MakePlate(40, 24);
+
+        // Wall part with a 10x10 cutout; a small selected part sits inside it.
+        var wall = new Part(
+            new Drawing(
+                "wall",
+                RectangleWithHole(20, 20, 5, 5, 10, 10)
+            ),
+            new Vector(0, 0)
+        );
+        plate.Parts.Add(wall);
+
+        var inside = new Part(new Drawing("inside", Rectangle(2, 2)), new Vector(9, 9));
+        var other = new Part(new Drawing("other", Rectangle(2, 2)), new Vector(30, 9));
+        plate.Parts.Add(inside);
+        plate.Parts.Add(other);
+
+        var result = Expander.Expand(
+            new List<Part> { inside, other },
+            plate,
+            new Expander.Options { MaxSpacing = 2 }
+        );
+
+        // Part-in-cutout is legal, never a material overlap.
+        Assert.False(MateriallyOverlaps(inside, wall));
+        Assert.False(MateriallyOverlaps(other, wall));
+        Assert.False(MateriallyOverlaps(inside, other));
+        Assert.True(result.AchievedSpacing >= 1.9);
+
+        // The part that started in the cutout must clear the hole walls too.
+        var holeLeft = 5;
+        var holeRight = 15;
+        var gapLeft = inside.Location.X - holeLeft;
+        var gapRight = holeRight - (inside.Location.X + 2);
+        var gapBottom = inside.Location.Y - holeLeft;
+        var gapTop = holeRight - (inside.Location.Y + 2);
+        var minGap = System.Math.Min(
+            System.Math.Min(gapLeft, gapRight),
+            System.Math.Min(gapBottom, gapTop)
+        );
+        Assert.True(minGap >= 1.9, $"closest hole-wall gap {minGap}");
+    }
+
+    [Fact]
+    public void Expand_DegenerateInputs_Throw()
+    {
+        var plate = MakePlate(10, 10);
+        var a = AddSquare(plate, 1, 1);
+        var stranger = new Part(new Drawing("stranger", Rectangle()), new Vector(50, 50));
+
+        Assert.Throws<ArgumentException>(() => Expander.Expand(new List<Part>(), plate));
+        Assert.Throws<ArgumentException>(() => Expander.Expand(new List<Part> { a }, plate));
+        Assert.Throws<ArgumentException>(() => Expander.Expand(new List<Part> { a, stranger }, plate));
+        Assert.Throws<ArgumentNullException>(() => Expander.Expand(new List<Part> { a, a }, null));
+    }
+
+    [Fact]
+    public void Expand_WallsAndUnselectedPairs_StayExactlyAtClearance()
+    {
+        // Selection must not be pushed to open gaps between parts it excludes.
+        var plate = MakePlate(40, 12);
+        var w1 = AddSquare(plate, 2, 4);
+        var w2 = AddSquare(plate, 6.5, 4); // 0.5 apart from w1, both unselected
+        var a = AddSquare(plate, 14, 4);
+        var b = AddSquare(plate, 20, 4);
+
+        Expander.Expand(new List<Part> { a, b }, plate);
+
+        Assert.Equal(2, w1.Location.X, 6);
+        Assert.Equal(6.5, w2.Location.X, 6);
+        Assert.True(a.Intersects(w1, out _) == false);
+        Assert.True(b.Intersects(w2, out _) == false);
+    }
+}

OpenNest.Engine.Tests/Jobs/NestLayoutCheckTests.cs

@@ -6,6 +6,52 @@ namespace OpenNest.Engine.Tests.Jobs;
 
 public class NestLayoutCheckTests
 {
+    [Theory]
+    [InlineData(null, false)]
+    [InlineData(1, true)]
+    [InlineData(2, false)]
+    [InlineData(3, false)]
+    public void MaxPlatesCountsPhysicalSheetsIncludingEmptyOnes(int? maxPlates, bool exceedsLimit)
+    {
+        var stock = new NestPlateStock("sheet", new Size(48, 96));
+        var job = new NestJob(Array.Empty<NestJobPart>(), new[] { stock }, new NestJobOptions(maxPlates: maxPlates));
+        var result = new NestJobResult(NestJobStatus.Complete, NestJobStopReason.Completed,
+            new[]
+            {
+                new NestJobPlateResult(7, stock, Array.Empty<NestJobPlacement>()),
+                new NestJobPlateResult(42, stock, Array.Empty<NestJobPlacement>()),
+            }, Array.Empty<PartFulfillment>(), Array.Empty<StockUsage>());
+
+        var violations = NestLayoutCheck.Violations(job, result);
+
+        if (exceedsLimit)
+            Assert.Contains(violations, v => v.Contains("MaxPlates") && v.Contains("2") && v.Contains("1"));
+        else
+            Assert.Empty(violations);
+    }
+
+    [Theory]
+    [InlineData("ghost", 1, 1, 0)]
+    [InlineData(null, 1, 1, 0)]
+    [InlineData("p", double.NaN, 1, 0)]
+    [InlineData("p", 1, double.PositiveInfinity, 0)]
+    [InlineData("p", 1, 1, double.NaN)]
+    public void MalformedPlacementsProduceDiagnosticsRatherThanThrowing(string? partId, double x, double y, double rotation)
+    {
+        var stock = new NestPlateStock("sheet", new Size(48, 96));
+        var job = new NestJob(new[]
+        {
+            new NestJobPart("p", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle()), 1),
+        }, new[] { stock });
+        var result = new NestJobResult(NestJobStatus.Complete, NestJobStopReason.Completed,
+            new[] { new NestJobPlateResult(0, stock, new[] { new NestJobPlacement(partId!, 0, x, y, rotation) }) },
+            Array.Empty<PartFulfillment>(), Array.Empty<StockUsage>());
+
+        var violations = NestLayoutCheck.Violations(job, result);
+
+        Assert.NotEmpty(violations);
+    }
+
     [Fact]
     public void TangentDiscsClearAtSafeMarginAcrossRadiiAnglesAndTolerances()
     {

OpenNest.Engine.Tests/Jobs/NestPipelineCommitTests.cs

@@ -0,0 +1,90 @@
+using OpenNest.Engine.Jobs;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestPipelineCommitTests
+{
+    private sealed class StubEngine(bool overlap) : INestingEngine
+    {
+        public NestJobResult Solve(NestJob job, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default) => new(
+                NestJobStatus.Complete, NestJobStopReason.Completed,
+                new[] { new NestJobPlateResult(0, job.Plates[0], new[]
+                {
+                    new NestJobPlacement(job.Parts[0].Id, 0, 2, 2, 0),
+                    new NestJobPlacement(job.Parts[0].Id, 1, overlap ? 2 : 20, 2, 0),
+                }) },
+                new[] { new PartFulfillment(job.Parts[0].Id, 2, 2, 0) },
+                new[] { new StockUsage(job.Plates[0].Id, 1, null) });
+    }
+
+    private static NestPipelineResult Result(Drawing drawing, bool overlap = false) =>
+        NestPipeline.Run(new StubEngine(overlap), "stub", new NestPipelineRequest("stub",
+            new[] { new NestItem { Drawing = drawing, Quantity = 2 } },
+            new[] { new NestPlateStock("sheet", new Size(48, 96), null, 0.25, new Spacing(1, 1), 1) }));
+
+    [Fact]
+    public void AppliesValidatedSettingsToEmptyPlateAndNeverFillsOccupiedPlate()
+    {
+        var drawing = new Drawing("part", TestDrawingFactory.Rectangle());
+        var nest = new Nest();
+        nest.Drawings.Add(drawing);
+        var occupied = nest.CreatePlate();
+        occupied.Parts.Add(new Part(drawing));
+        var empty = nest.CreatePlate();
+        empty.Quantity = 7;
+        empty.Quadrant = 3;
+        empty.Size = new Size(4, 8);
+        empty.EdgeSpacing = new Spacing(0, 0);
+        using var manager = new PlateManager(nest);
+        var result = Result(drawing);
+        Assert.True(result.IsValid, string.Join("; ", result.Violations));
+
+        var applied = NestPipelineCommit.ApplyToEmptyPlates(result, manager);
+
+        Assert.Same(empty, Assert.Single(applied));
+        Assert.Single(occupied.Parts);
+        Assert.Equal(2, empty.Parts.Count);
+        Assert.Equal(1, empty.Quantity);
+        Assert.Equal(1, empty.Quadrant);
+        Assert.Equal(result.Job.Plates[0].Size, empty.Size);
+        Assert.Equal(result.Job.Plates[0].EdgeSpacing, empty.EdgeSpacing);
+        Assert.Equal(0.25, empty.PartSpacing);
+        Assert.All(empty.Parts, p => Assert.Same(drawing, p.BaseDrawing));
+        Assert.Equal(3, drawing.Quantity.Nested);
+    }
+
+    [Fact]
+    public void InvalidResultRequiresExplicitConsentAndDiscardDoesNotMutateNest()
+    {
+        var drawing = new Drawing("part", TestDrawingFactory.Rectangle());
+        var nest = new Nest();
+        nest.Drawings.Add(drawing);
+        var empty = nest.CreatePlate();
+        using var manager = new PlateManager(nest);
+        var result = Result(drawing, overlap: true);
+        Assert.False(result.IsValid);
+
+        Assert.Throws<InvalidOperationException>(() => NestPipelineCommit.ApplyToEmptyPlates(result, manager));
+        Assert.Same(empty, Assert.Single(nest.Plates));
+        Assert.Empty(empty.Parts);
+        Assert.Equal(0, drawing.Quantity.Nested);
+
+        var applied = NestPipelineCommit.ApplyToEmptyPlates(result, manager, allowInvalid: true);
+        Assert.Equal(2, Assert.Single(applied).Parts.Count);
+    }
+
+    [Fact]
+    public void CancelledCommitDoesNotCreateAnyPlate()
+    {
+        var drawing = new Drawing("part", TestDrawingFactory.Rectangle());
+        var nest = new Nest();
+        using var manager = new PlateManager(nest);
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        Assert.ThrowsAny<OperationCanceledException>(() =>
+            NestPipelineCommit.ApplyToEmptyPlates(Result(drawing), manager, token: cts.Token));
+        Assert.Empty(nest.Plates);
+    }
+}

OpenNest.Engine.Tests/Jobs/NestPipelineTests.cs

@@ -0,0 +1,271 @@
+using OpenNest.CNC;
+using OpenNest.Engine.Jobs;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestPipelineTests
+{
+    private static NestPlateStock Sheet() =>
+        new("sheet", new Size(48, 96), quantity: null, partSpacing: 0.25);
+
+    private static NestItem Item(string name, int quantity) =>
+        new()
+        {
+            Drawing = new Drawing(name, TestDrawingFactory.Rectangle()),
+            Quantity = quantity,
+        };
+
+    private static NestPipelineRequest Request(string engine, params NestItem[] items) =>
+        new(engine, items, new[] { Sheet() });
+
+    private static NestJobResult OnePlate(NestJob job, params NestJobPlacement[] placements) =>
+        new(
+            NestJobStatus.Complete,
+            NestJobStopReason.Completed,
+            new[] { new NestJobPlateResult(0, job.Plates[0], placements) },
+            job.Parts.Select(p => new PartFulfillment(p.Id, p.Quantity, p.Quantity, 0)),
+            new[] { new StockUsage(job.Plates[0].Id, 1, null) }
+        );
+
+    private sealed class StubEngine(Func<NestJob, NestJobResult> solve) : INestingEngine
+    {
+        public NestJobResult Solve(
+            NestJob job,
+            IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default
+        ) => solve(job);
+    }
+
+    [Fact]
+    public void RegisteredEngineResultIsValidatedAndBoundToCallerDrawings()
+    {
+        var item = Item("bracket", 10);
+        var codes = item.Drawing.Program.Codes.Count;
+
+        var result = NestPipeline.Run(Request("Default", item));
+
+        Assert.True(result.IsValid, string.Join("; ", result.Violations));
+        Assert.True(result.CanKeep);
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        var parts = result.Plates.SelectMany(p => p.Parts).ToList();
+        Assert.Equal(10, parts.Count);
+        Assert.All(parts, part => Assert.Same(item.Drawing, part.BaseDrawing));
+        Assert.All(result.Plates, plate => Assert.Same(result.Job.Plates[0], plate.Stock));
+        Assert.Equal(10, item.Quantity);
+        Assert.Equal(codes, item.Drawing.Program.Codes.Count);
+        Assert.Equal(0, item.Drawing.Quantity.Nested);
+    }
+
+    [Fact]
+    public void OverlappingEngineOutputIsReportedByDrawingNameWithoutThrowing()
+    {
+        var item = Item("bracket", 2);
+        var before = PartGeometrySnapshot.FromProgram(item.Drawing.Program).Motions;
+        var engine = new StubEngine(job =>
+            OnePlate(
+                job,
+                new NestJobPlacement(job.Parts[0].Id, 0, 1, 1, 0),
+                new NestJobPlacement(job.Parts[0].Id, 1, 1, 1, 0)
+            )
+        );
+
+        var result = NestPipeline.Run(engine, "Overlapper", Request("Overlapper", item));
+
+        Assert.False(result.IsValid);
+        Assert.True(result.CanKeep);
+        Assert.Contains(result.Violations, v => v.Contains("bracket") && v.Contains("spacing"));
+        Assert.Equal(2, result.Plates.Single().Parts.Count);
+        Assert.All(result.Plates.Single().Parts, part => Assert.Same(item.Drawing, part.BaseDrawing));
+        Assert.Equal(before, PartGeometrySnapshot.FromProgram(item.Drawing.Program).Motions);
+        Assert.Equal(2, item.Quantity);
+        Assert.Equal(0, item.Drawing.Quantity.Nested);
+    }
+
+    [Theory]
+    [InlineData("ghost")]
+    [InlineData(null)]
+    public void UnknownOrNullRequirementMakesTheEntireProposalNonKeepable(string? partId)
+    {
+        var item = Item("bracket", 1);
+        var before = PartGeometrySnapshot.FromProgram(item.Drawing.Program).Motions;
+        var engine = new StubEngine(job => new NestJobResult(
+            NestJobStatus.Complete,
+            NestJobStopReason.Completed,
+            new[]
+            {
+                new NestJobPlateResult(0, job.Plates[0], new[] { new NestJobPlacement(job.Parts[0].Id, 0, 1, 1, 0) }),
+                new NestJobPlateResult(1, job.Plates[0], new[] { new NestJobPlacement(partId!, 0, 30, 1, 0) }),
+            },
+            Array.Empty<PartFulfillment>(),
+            Array.Empty<StockUsage>()
+        ));
+
+        var result = NestPipeline.Run(engine, "Ghost", Request("Ghost", item));
+
+        Assert.False(result.IsValid);
+        Assert.False(result.CanKeep);
+        Assert.Contains(result.Violations, v => v.Contains(partId ?? "null") && v.Contains("Plate 1"));
+        Assert.Empty(result.Plates);
+        Assert.Equal(2, result.Raw.Plates.Count);
+        Assert.Equal(before, PartGeometrySnapshot.FromProgram(item.Drawing.Program).Motions);
+        Assert.Equal(1, item.Quantity);
+        Assert.Equal(0, item.Drawing.Quantity.Nested);
+    }
+
+    [Theory]
+    [InlineData(double.NaN, 1, 0, "X")]
+    [InlineData(double.PositiveInfinity, 1, 0, "X")]
+    [InlineData(double.NegativeInfinity, 1, 0, "X")]
+    [InlineData(1, double.NaN, 0, "Y")]
+    [InlineData(1, double.PositiveInfinity, 0, "Y")]
+    [InlineData(1, double.NegativeInfinity, 0, "Y")]
+    [InlineData(1, 1, double.NaN, "Rotation")]
+    [InlineData(1, 1, double.PositiveInfinity, "Rotation")]
+    [InlineData(1, 1, double.NegativeInfinity, "Rotation")]
+    public void NonfinitePoseIsReportedAndNeverProposed(double x, double y, double rotation, string field)
+    {
+        var item = Item("bracket", 2);
+        var before = PartGeometrySnapshot.FromProgram(item.Drawing.Program).Motions;
+        var engine = new StubEngine(job => OnePlate(job,
+            new NestJobPlacement(job.Parts[0].Id, 0, 1, 1, 0),
+            new NestJobPlacement(job.Parts[0].Id, 1, x, y, rotation)));
+
+        var result = NestPipeline.Run(engine, "Nonfinite", Request("Nonfinite", item));
+
+        Assert.False(result.IsValid);
+        Assert.False(result.CanKeep);
+        Assert.Empty(result.Plates);
+        Assert.Contains(result.Violations, v => v.Contains(field) && v.Contains("finite") && v.Contains("bracket"));
+        Assert.Equal(before, PartGeometrySnapshot.FromProgram(item.Drawing.Program).Motions);
+        Assert.Equal(2, item.Quantity);
+        Assert.Equal(0, item.Drawing.Quantity.Nested);
+    }
+
+    [Fact]
+    public void ReportsEveryStructuralViolationWithoutMaterializingAnyGeometry()
+    {
+        var engine = new StubEngine(job => OnePlate(job,
+            new NestJobPlacement("ghost", 0, double.NaN, double.PositiveInfinity, double.NegativeInfinity),
+            new NestJobPlacement(null!, 0, 1, 1, 0),
+            new NestJobPlacement(job.Parts[0].Id, 0, double.NegativeInfinity, 1, 0)));
+
+        var result = NestPipeline.Run(engine, "Malformed", Request("Malformed", Item("bracket", 1)));
+
+        Assert.False(result.CanKeep);
+        Assert.Empty(result.Plates);
+        Assert.Equal(6, result.Violations.Count);
+        Assert.Contains(result.Violations, v => v.Contains("ghost") && v.Contains("not part of this job"));
+        Assert.Contains(result.Violations, v => v.Contains("null") && v.Contains("not part of this job"));
+        Assert.Equal(2, result.Violations.Count(v => v.Contains("nonfinite X")));
+        Assert.Contains(result.Violations, v => v.Contains("nonfinite Y"));
+        Assert.Contains(result.Violations, v => v.Contains("nonfinite Rotation"));
+    }
+
+    [Fact]
+    public void ExceedingMaxPlatesIsInvalidButRemainsFullyKeepable()
+    {
+        var item = Item("bracket", 2);
+        var request = Request("TooManySheets", item) with { Options = new NestJobOptions(maxPlates: 1) };
+        var engine = new StubEngine(job => new NestJobResult(
+            NestJobStatus.Complete,
+            NestJobStopReason.Completed,
+            Enumerable.Range(0, 2).Select(i => new NestJobPlateResult(i, job.Plates[0],
+                new[] { new NestJobPlacement(job.Parts[0].Id, i, 1, 1, 0) })),
+            new[] { new PartFulfillment(job.Parts[0].Id, 2, 2, 0) },
+            new[] { new StockUsage(job.Plates[0].Id, 2, null) }
+        ));
+
+        var result = NestPipeline.Run(engine, "TooManySheets", request);
+
+        Assert.False(result.IsValid);
+        Assert.True(result.CanKeep);
+        Assert.Contains(result.Violations, v => v.Contains("MaxPlates") && v.Contains("2") && v.Contains("1"));
+        Assert.Equal(2, result.Plates.Count);
+        Assert.All(result.Plates, plate => Assert.Same(item.Drawing, Assert.Single(plate.Parts).BaseDrawing));
+        Assert.Equal(2, item.Quantity);
+        Assert.Equal(0, item.Drawing.Quantity.Nested);
+    }
+
+    [Fact]
+    public void InvalidStockIsRejectedBeforeCallingAnArbitraryEngine()
+    {
+        var called = false;
+        var engine = new StubEngine(job =>
+        {
+            called = true;
+            return OnePlate(job);
+        });
+        var request = Request("Unchecked", Item("bracket", 1)) with
+        {
+            Stock = new[] { new NestPlateStock("bad", new Size(48, 96), partSpacing: double.NaN) },
+        };
+
+        var error = Assert.Throws<ArgumentException>(() => NestPipeline.Run(engine, "Unchecked", request));
+
+        Assert.Contains("Invalid stock", error.Message);
+        Assert.False(called);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void InvalidGeometryIsRejectedBeforeCallingAnArbitraryEngine(bool nonfinite)
+    {
+        var item = Item("bracket", 1);
+        if (nonfinite)
+            ((Motion)item.Drawing.Program.Codes[1]).EndPoint = new Vector(double.NaN, 0);
+        else
+            item.Drawing.Program.Codes.Clear();
+        var called = false;
+        var engine = new StubEngine(job =>
+        {
+            called = true;
+            return OnePlate(job);
+        });
+
+        var error = Assert.Throws<ArgumentException>(() =>
+            NestPipeline.Run(engine, "Unchecked", Request("Unchecked", item)));
+
+        Assert.Contains("Geometry must contain finite motions", error.Message);
+        Assert.False(called);
+        Assert.Equal(1, item.Quantity);
+        Assert.Equal(0, item.Drawing.Quantity.Nested);
+    }
+
+    [Fact]
+    public void UnknownEngineNameListsRegisteredEngines()
+    {
+        var error = Assert.Throws<NotSupportedException>(() =>
+            NestPipeline.Run(Request("Mystery Engine", Item("bracket", 1)))
+        );
+
+        Assert.Contains("Default", error.Message);
+    }
+
+    [Fact]
+    public void CancellationDuringSolveDiscardsEvenAnEngineThatReturnsNormally()
+    {
+        using var cts = new CancellationTokenSource();
+        var engine = new StubEngine(job =>
+        {
+            cts.Cancel();
+            return OnePlate(job, new NestJobPlacement(job.Parts[0].Id, 0, 1, 1, 0));
+        });
+
+        Assert.ThrowsAny<OperationCanceledException>(() =>
+            NestPipeline.Run(engine, "IgnoresStop", Request("IgnoresStop", Item("bracket", 1)), null, cts.Token)
+        );
+    }
+
+    [Fact]
+    public void CancellationPropagatesWithoutAResult()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+
+        Assert.ThrowsAny<OperationCanceledException>(() =>
+            NestPipeline.Run(Request("Default", Item("bracket", 1)), null, cts.Token)
+        );
+    }
+}

OpenNest.Engine.Tests/Jobs/NestResultBinderTests.cs

@@ -0,0 +1,32 @@
+using OpenNest.Engine.Jobs;
+using OpenNest.Engine.Jobs.Adapters;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestResultBinderTests
+{
+    [Theory]
+    [InlineData("ghost", 1, 1, 0)]
+    [InlineData(null, 1, 1, 0)]
+    [InlineData("p", double.NaN, 1, 0)]
+    [InlineData("p", 1, double.PositiveInfinity, 0)]
+    [InlineData("p", 1, 1, double.NaN)]
+    public void MalformedSheetCannotBePartiallyBound(string? partId, double x, double y, double rotation)
+    {
+        var drawing = new Drawing("bracket", TestDrawingFactory.Rectangle());
+        var before = PartGeometrySnapshot.FromProgram(drawing.Program).Motions;
+        var sheet = new NestJobPlateResult(0, new NestPlateStock("sheet", new Size(48, 96)),
+            new[]
+            {
+                new NestJobPlacement("p", 0, 1, 1, 0),
+                new NestJobPlacement(partId!, 1, x, y, rotation),
+            });
+        var drawings = new Dictionary<string, Drawing> { ["p"] = drawing };
+
+        Assert.Throws<ArgumentException>(() => NestResultBinder.Bind(sheet, drawings));
+
+        Assert.Equal(before, PartGeometrySnapshot.FromProgram(drawing.Program).Motions);
+        Assert.Equal(0, drawing.Quantity.Nested);
+    }
+}

OpenNest.Engine.Tests/Jobs/NestStockBuilderTests.cs

@@ -0,0 +1,68 @@
+using OpenNest.Engine.Jobs;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestStockBuilderTests
+{
+    private static Plate Template() => new(new Size(48, 96))
+    {
+        Quantity = 7,
+        PartSpacing = 0.25,
+        EdgeSpacing = new Spacing(1, 2, 3, 4),
+        Quadrant = 3,
+    };
+
+    [Fact]
+    public void TemplateWithoutOptionsUsesUnlimitedStockAndSnapshotsSettings()
+    {
+        var template = Template();
+        var stock = Assert.Single(NestStockBuilder.FromTemplate(template, null));
+        Assert.Equal("plate", stock.Id);
+        Assert.Null(stock.Quantity);
+        Assert.Equal(template.Size, stock.Size);
+        Assert.Equal(template.PartSpacing, stock.PartSpacing);
+        Assert.Equal(template.EdgeSpacing, stock.EdgeSpacing);
+        Assert.Equal(template.Quadrant, stock.Quadrant);
+        template.Size = new Size(60, 120);
+        template.EdgeSpacing = default;
+        Assert.Equal(new Size(48, 96), stock.Size);
+        Assert.Equal(new Spacing(1, 2, 3, 4), stock.EdgeSpacing);
+    }
+
+    [Fact]
+    public void OptionsHaveStableDistinctIdsAndCopyTemplateSettings()
+    {
+        var template = Template();
+        var options = new[]
+        {
+            new PlateOption { Width = 60, Length = 120 },
+            new PlateOption { Width = 72, Length = 144 },
+        };
+        var stock = NestStockBuilder.FromTemplate(template, options, quantityPerOption: 2);
+        Assert.Equal(new[] { "option-0", "option-1" }, stock.Select(s => s.Id));
+        Assert.Equal(new[] { new Size(60, 120), new Size(72, 144) }, stock.Select(s => s.Size));
+        Assert.All(stock, s =>
+        {
+            Assert.Equal(2, s.Quantity);
+            Assert.Equal(template.EdgeSpacing, s.EdgeSpacing);
+            Assert.Equal(template.PartSpacing, s.PartSpacing);
+            Assert.Equal(template.Quadrant, s.Quadrant);
+        });
+        Assert.Equal(new Size(48, 96), template.Size);
+    }
+
+    [Fact]
+    public void SinglePlateOffersExactlyOneSheetNotPlateRepeatQuantity()
+    {
+        var stock = Assert.Single(NestStockBuilder.SinglePlate(Template()));
+        Assert.Equal(1, stock.Quantity);
+    }
+
+    [Fact]
+    public void MissingTemplateIsRejected()
+    {
+        Assert.Throws<ArgumentNullException>(() => NestStockBuilder.FromTemplate(null, null));
+        Assert.Throws<ArgumentNullException>(() => NestStockBuilder.SinglePlate(null));
+    }
+}

OpenNest.Engine/BestFit/CpuDistanceComputer.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using OpenNest.Geometry;
-using OpenNest.Math;
 
 namespace OpenNest.Engine.BestFit
 {
@@ -13,117 +12,21 @@ namespace OpenNest.Engine.BestFit
             SlideOffset[] offsets
         )
         {
-            var count = offsets.Length;
+            var results = new double[offsets.Length];
-            var results = new double[count];
+            var movingVertices = Vertices(movingTemplateLines);
+            var stationaryVertices = Vertices(stationaryLines);
+            var contacts = SlideContactClassifier.FromLines(
+                movingTemplateLines, Vector.Zero, stationaryLines, Vector.Zero).Prepare();
 
-            var allMovingVerts = ExtractUniqueVertices(movingTemplateLines);
+            System.Threading.Tasks.Parallel.For(0, offsets.Length, i =>
-            var allStationaryVerts = ExtractUniqueVertices(stationaryLines);
-
-            var vertexCache =
-                new Dictionary<(double, double), (Vector[] leading, Vector[] facing)>();
-
-            foreach (var offset in offsets)
-            {
-                var key = (offset.DirX, offset.DirY);
-                if (vertexCache.ContainsKey(key))
-                    continue;
-
-                var leading = FilterVerticesByProjection(
-                    allMovingVerts,
-                    offset.DirX,
-                    offset.DirY,
-                    keepHigh: true
-                );
-                var facing = FilterVerticesByProjection(
-                    allStationaryVerts,
-                    offset.DirX,
-                    offset.DirY,
-                    keepHigh: false
-                );
-                vertexCache[key] = (leading, facing);
-            }
-
-            System.Threading.Tasks.Parallel.For(
-                0,
-                count,
-                i =>
             {
                 var offset = offsets[i];
-                    var dirX = offset.DirX;
+                var source = new LineSlideEvents(
-                    var dirY = offset.DirY;
+                    movingTemplateLines, movingVertices, offset.Dx, offset.Dy,
-                    var oppX = -dirX;
+                    stationaryLines, stationaryVertices, offset.DirX, offset.DirY);
-                    var oppY = -dirY;
+                results[i] = SlideResolver.FirstBlocking(ref source,
-
+                    contacts.At(new Vector(offset.Dx, offset.Dy), Vector.Zero), offset.DirX, offset.DirY);
-                    var (leadingMoving, facingStationary) = vertexCache[(dirX, dirY)];
+            });
-
-                    var minDist = double.MaxValue;
-
-                    for (var v = 0; v < leadingMoving.Length; v++)
-                    {
-                        var vx = leadingMoving[v].X + offset.Dx;
-                        var vy = leadingMoving[v].Y + offset.Dy;
-
-                        for (var j = 0; j < stationaryLines.Count; j++)
-                        {
-                            var e = stationaryLines[j];
-                            var d = SpatialQuery.RayEdgeDistance(
-                                vx,
-                                vy,
-                                e.StartPoint.X,
-                                e.StartPoint.Y,
-                                e.EndPoint.X,
-                                e.EndPoint.Y,
-                                dirX,
-                                dirY
-                            );
-
-                            if (d < minDist)
-                            {
-                                minDist = d;
-                                if (d <= 0)
-                                {
-                                    results[i] = 0;
-                                    return;
-                                }
-                            }
-                        }
-                    }
-
-                    for (var v = 0; v < facingStationary.Length; v++)
-                    {
-                        var svx = facingStationary[v].X;
-                        var svy = facingStationary[v].Y;
-
-                        for (var j = 0; j < movingTemplateLines.Count; j++)
-                        {
-                            var e = movingTemplateLines[j];
-                            var d = SpatialQuery.RayEdgeDistance(
-                                svx,
-                                svy,
-                                e.StartPoint.X + offset.Dx,
-                                e.StartPoint.Y + offset.Dy,
-                                e.EndPoint.X + offset.Dx,
-                                e.EndPoint.Y + offset.Dy,
-                                oppX,
-                                oppY
-                            );
-
-                            if (d < minDist)
-                            {
-                                minDist = d;
-                                if (d <= 0)
-                                {
-                                    results[i] = 0;
-                                    return;
-                                }
-                            }
-                        }
-                    }
-
-                    results[i] = minDist;
-                }
-            );
-
             return results;
         }
 
@@ -133,347 +36,26 @@ namespace OpenNest.Engine.BestFit
             SlideOffset[] offsets
         )
         {
-            var count = offsets.Length;
+            var results = new double[offsets.Length];
-            var results = new double[count];
+            var movingVertices = SpatialQuery.ExtractEntityVertices(movingEntities);
+            var stationaryVertices = SpatialQuery.ExtractEntityVertices(stationaryEntities);
+            var contacts = new SlideContactClassifier(movingEntities, stationaryEntities).Prepare();
 
-            var allMovingVerts = ExtractVerticesFromEntities(movingEntities);
+            // All vertices participate: a leading-half filter can miss the next contact
-            var allStationaryVerts = ExtractVerticesFromEntities(stationaryEntities);
+            // after sliding past an initial touch on a concave boundary.
-
+            System.Threading.Tasks.Parallel.For(0, offsets.Length, i =>
-            var movingCurves = ExtractCurveParams(movingEntities);
-            var stationaryCurves = ExtractCurveParams(stationaryEntities);
-
-            var vertexCache =
-                new Dictionary<(double, double), (Vector[] leading, Vector[] facing)>();
-
-            foreach (var offset in offsets)
-            {
-                var key = (offset.DirX, offset.DirY);
-                if (vertexCache.ContainsKey(key))
-                    continue;
-
-                var leading = FilterVerticesByProjection(
-                    allMovingVerts,
-                    offset.DirX,
-                    offset.DirY,
-                    keepHigh: true
-                );
-                var facing = FilterVerticesByProjection(
-                    allStationaryVerts,
-                    offset.DirX,
-                    offset.DirY,
-                    keepHigh: false
-                );
-                vertexCache[key] = (leading, facing);
-            }
-
-            System.Threading.Tasks.Parallel.For(
-                0,
-                count,
-                i =>
             {
                 var offset = offsets[i];
-                    var dirX = offset.DirX;
+                var source = new EntitySlideEvents(
-                    var dirY = offset.DirY;
+                    movingEntities, movingVertices, offset.Dx, offset.Dy,
-                    var oppX = -dirX;
+                    stationaryEntities, stationaryVertices, offset.DirX, offset.DirY, arcToLine: true);
-                    var oppY = -dirY;
+                results[i] = SlideResolver.FirstBlocking(ref source,
-
+                    contacts.At(new Vector(offset.Dx, offset.Dy), Vector.Zero), offset.DirX, offset.DirY);
-                    var (leadingMoving, facingStationary) = vertexCache[(dirX, dirY)];
+            });
-
-                    var minDist = double.MaxValue;
-
-                    // Case 1: Leading moving vertices → stationary entities
-                    for (var v = 0; v < leadingMoving.Length; v++)
-                    {
-                        var vx = leadingMoving[v].X + offset.Dx;
-                        var vy = leadingMoving[v].Y + offset.Dy;
-
-                        for (var j = 0; j < stationaryEntities.Count; j++)
-                        {
-                            var d = RayEntityDistance(
-                                vx,
-                                vy,
-                                stationaryEntities[j],
-                                0,
-                                0,
-                                dirX,
-                                dirY
-                            );
-
-                            if (d < minDist)
-                            {
-                                minDist = d;
-                                if (d <= 0)
-                                {
-                                    results[i] = 0;
-                                    return;
-                                }
-                            }
-                        }
-                    }
-
-                    // Case 2: Facing stationary vertices → moving entities (opposite direction)
-                    for (var v = 0; v < facingStationary.Length; v++)
-                    {
-                        var svx = facingStationary[v].X;
-                        var svy = facingStationary[v].Y;
-
-                        for (var j = 0; j < movingEntities.Count; j++)
-                        {
-                            var d = RayEntityDistance(
-                                svx,
-                                svy,
-                                movingEntities[j],
-                                offset.Dx,
-                                offset.Dy,
-                                oppX,
-                                oppY
-                            );
-
-                            if (d < minDist)
-                            {
-                                minDist = d;
-                                if (d <= 0)
-                                {
-                                    results[i] = 0;
-                                    return;
-                                }
-                            }
-                        }
-                    }
-
-                    // Phase 3: Curve-to-curve direct distance.
-                    // Vertex sampling misses the true contact between two curved entities
-                    // when the approach angle doesn't align with a sampled vertex.
-                    for (var m = 0; m < movingCurves.Length; m++)
-                    {
-                        var mc = movingCurves[m];
-                        var mcx = mc.Cx + offset.Dx;
-                        var mcy = mc.Cy + offset.Dy;
-
-                        for (var s = 0; s < stationaryCurves.Length; s++)
-                        {
-                            var sc = stationaryCurves[s];
-                            var d = SpatialQuery.CurveTangencyDistance(
-                                mcx, mcy, mc.Radius, mc.Entity as Arc,
-                                sc.Cx, sc.Cy, sc.Radius, sc.Entity as Arc, dirX, dirY);
-
-                            if (d >= minDist)
-                                continue;
-
-                            minDist = d;
-                            if (d <= 0)
-                            {
-                                results[i] = 0;
-                                return;
-                            }
-                        }
-                    }
-
-                    results[i] = minDist;
-                }
-            );
-
             return results;
         }
 
-        private readonly struct CurveParams
+        private static Vector[] Vertices(List<Line> lines) =>
-        {
+            lines.SelectMany(line => new[] { line.StartPoint, line.EndPoint }).Distinct().ToArray();
-            public readonly Entity Entity;
-            public readonly double Cx,
-                Cy,
-                Radius;
-
-            public CurveParams(Entity entity, double cx, double cy, double radius)
-            {
-                Entity = entity;
-                Cx = cx;
-                Cy = cy;
-                Radius = radius;
-            }
-        }
-
-        private static CurveParams[] ExtractCurveParams(List<Entity> entities)
-        {
-            var curves = new List<CurveParams>();
-            for (var i = 0; i < entities.Count; i++)
-            {
-                if (entities[i] is Circle circle)
-                    curves.Add(
-                        new CurveParams(circle, circle.Center.X, circle.Center.Y, circle.Radius)
-                    );
-                else if (entities[i] is Arc arc)
-                    curves.Add(new CurveParams(arc, arc.Center.X, arc.Center.Y, arc.Radius));
-            }
-            return curves.ToArray();
-        }
-
-        private static double RayEntityDistance(
-            double vx,
-            double vy,
-            Entity entity,
-            double entityOffsetX,
-            double entityOffsetY,
-            double dirX,
-            double dirY
-        )
-        {
-            if (entity is Line line)
-            {
-                return SpatialQuery.RayEdgeDistance(
-                    vx,
-                    vy,
-                    line.StartPoint.X + entityOffsetX,
-                    line.StartPoint.Y + entityOffsetY,
-                    line.EndPoint.X + entityOffsetX,
-                    line.EndPoint.Y + entityOffsetY,
-                    dirX,
-                    dirY
-                );
-            }
-
-            if (entity is Arc arc)
-            {
-                return SpatialQuery.RayArcDistance(
-                    vx,
-                    vy,
-                    arc.Center.X + entityOffsetX,
-                    arc.Center.Y + entityOffsetY,
-                    arc.Radius,
-                    arc.StartAngle,
-                    arc.EndAngle,
-                    arc.IsReversed,
-                    dirX,
-                    dirY
-                );
-            }
-
-            if (entity is Circle circle)
-            {
-                return SpatialQuery.RayCircleDistance(
-                    vx,
-                    vy,
-                    circle.Center.X + entityOffsetX,
-                    circle.Center.Y + entityOffsetY,
-                    circle.Radius,
-                    dirX,
-                    dirY
-                );
-            }
-
-            return double.MaxValue;
-        }
-
-        private static Vector[] ExtractVerticesFromEntities(List<Entity> entities)
-        {
-            var vertices = new HashSet<Vector>();
-
-            for (var i = 0; i < entities.Count; i++)
-            {
-                var entity = entities[i];
-
-                if (entity is Line line)
-                {
-                    vertices.Add(line.StartPoint);
-                    vertices.Add(line.EndPoint);
-                }
-                else if (entity is Arc arc)
-                {
-                    vertices.Add(arc.StartPoint());
-                    vertices.Add(arc.EndPoint());
-                    AddArcExtremes(vertices, arc);
-                }
-                else if (entity is Circle circle)
-                {
-                    // Four cardinal points
-                    vertices.Add(new Vector(circle.Center.X + circle.Radius, circle.Center.Y));
-                    vertices.Add(new Vector(circle.Center.X - circle.Radius, circle.Center.Y));
-                    vertices.Add(new Vector(circle.Center.X, circle.Center.Y + circle.Radius));
-                    vertices.Add(new Vector(circle.Center.X, circle.Center.Y - circle.Radius));
-                }
-            }
-
-            return vertices.ToArray();
-        }
-
-        private static void AddArcExtremes(HashSet<Vector> points, Arc arc)
-        {
-            var a1 = arc.StartAngle;
-            var a2 = arc.EndAngle;
-            var reversed = arc.IsReversed;
-
-            if (reversed)
-                Generic.Swap(ref a1, ref a2);
-
-            // Right (0°)
-            if (Angle.IsBetweenRad(Angle.TwoPI, a1, a2))
-                points.Add(new Vector(arc.Center.X + arc.Radius, arc.Center.Y));
-
-            // Top (90°)
-            if (Angle.IsBetweenRad(Angle.HalfPI, a1, a2))
-                points.Add(new Vector(arc.Center.X, arc.Center.Y + arc.Radius));
-
-            // Left (180°)
-            if (Angle.IsBetweenRad(System.Math.PI, a1, a2))
-                points.Add(new Vector(arc.Center.X - arc.Radius, arc.Center.Y));
-
-            // Bottom (270°)
-            if (Angle.IsBetweenRad(System.Math.PI * 1.5, a1, a2))
-                points.Add(new Vector(arc.Center.X, arc.Center.Y - arc.Radius));
-        }
-
-        private static Vector[] ExtractUniqueVertices(List<Line> lines)
-        {
-            var vertices = new HashSet<Vector>();
-            for (var i = 0; i < lines.Count; i++)
-            {
-                vertices.Add(lines[i].StartPoint);
-                vertices.Add(lines[i].EndPoint);
-            }
-            return vertices.ToArray();
-        }
-
-        private static Vector[] FilterVerticesByProjection(
-            Vector[] vertices,
-            double dirX,
-            double dirY,
-            bool keepHigh
-        )
-        {
-            if (vertices.Length == 0)
-                return vertices;
-
-            var projections = new double[vertices.Length];
-            var min = double.MaxValue;
-            var max = double.MinValue;
-
-            for (var i = 0; i < vertices.Length; i++)
-            {
-                projections[i] = vertices[i].X * dirX + vertices[i].Y * dirY;
-                if (projections[i] < min)
-                    min = projections[i];
-                if (projections[i] > max)
-                    max = projections[i];
-            }
-
-            var midpoint = (min + max) / 2;
-            var count = 0;
-
-            for (var i = 0; i < vertices.Length; i++)
-            {
-                if (keepHigh ? projections[i] >= midpoint : projections[i] <= midpoint)
-                    count++;
-            }
-
-            var result = new Vector[count];
-            var idx = 0;
-
-            for (var i = 0; i < vertices.Length; i++)
-            {
-                if (keepHigh ? projections[i] >= midpoint : projections[i] <= midpoint)
-                    result[idx++] = vertices[i];
-            }
-
-            return result;
-        }
     }
 }

OpenNest.Engine/BestFit/GpuDistanceComputer.cs

@@ -18,6 +18,15 @@ namespace OpenNest.Engine.BestFit
             SlideOffset[] offsets
         )
         {
+            // ISlideComputer is axis-only; do not quantize an arbitrary direction into
+            // an unrelated cardinal push. Native curves already use this same fallback.
+            foreach (var offset in offsets)
+            {
+                if (!((offset.DirX == 0 && System.Math.Abs(offset.DirY) == 1)
+                    || (offset.DirY == 0 && System.Math.Abs(offset.DirX) == 1)))
+                    return new CpuDistanceComputer().ComputeDistances(stationaryLines, movingTemplateLines, offsets);
+            }
+
             var stationarySegments = SpatialQuery.FlattenLines(stationaryLines);
             var movingSegments = SpatialQuery.FlattenLines(movingTemplateLines);
             var count = offsets.Length;
@@ -55,7 +64,7 @@ namespace OpenNest.Engine.BestFit
 
         /// <summary>
         /// Maps a unit direction vector to a PushDirection int for the GPU interface.
-        /// Left=0, Down=1, Right=2, Up=3.
+        /// Up=0, Down=1, Left=2, Right=3.
         /// </summary>
         private static int DirectionVectorToInt(double dirX, double dirY)
         {

OpenNest.Engine/BestFit/ISlideComputer.cs

@@ -9,7 +9,8 @@ namespace OpenNest.Engine.BestFit
     public interface ISlideComputer : IDisposable
     {
         /// <summary>
-        /// Computes the minimum directional distance for each offset position.
+        /// Computes the first blocking contact distance for each offset position.
+        /// Separating/tangential contacts on closed boundaries do not block.
         /// </summary>
         /// <param name="stationarySegments">Flat array [x1,y1,x2,y2, ...] for stationary edges.</param>
         /// <param name="stationaryCount">Number of line segments in stationarySegments.</param>
@@ -30,7 +31,7 @@ namespace OpenNest.Engine.BestFit
         );
 
         /// <summary>
-        /// Computes minimum directional distance for offsets with per-offset directions.
+        /// Computes first blocking contact distances with per-offset directions.
         /// Uploads segment data once for all offsets, reducing GPU round-trips.
         /// </summary>
         double[] ComputeBatchMultiDir(

OpenNest.Engine/Fill/Compactor.cs

@@ -127,24 +127,20 @@ namespace OpenNest.Engine.Fill
                                     : PartGeometry.GetPerimeterEntities(moving)
                             );
 
+                    // A moving part can be inside an obstacle's cutout. Omitting that
+                    // loop would let it cross the inner wall before seeing the perimeter.
                     obstacleEntities[i] ??=
                         halfSpacing > 0
-                            ? PartGeometry.GetOffsetPerimeterEntities(obstacleParts[i], halfSpacing)
+                            ? PartGeometry.GetOffsetPartEntities(obstacleParts[i], halfSpacing)
-                            : PartGeometry.GetPerimeterEntities(obstacleParts[i]);
+                            : PartGeometry.GetPartEntities(obstacleParts[i]);
 
+                    // Contacts left by a previous push only block directions that would
+                    // push material into material; the kernel classifies them.
                     var d = SpatialQuery.DirectionalDistance(
                         movingEntities,
                         obstacleEntities[i],
                         direction
                     );
-                    if (
-                        d <= Tolerance.Epsilon
-                        && partSpacing <= Tolerance.Epsilon
-                        && CanNudgeWithoutOverlap(moving, obstacleParts[i], direction)
-                    )
-                    {
-                        continue;
-                    }
 
                     if (d < distance)
                         distance = d;
@@ -176,27 +172,25 @@ namespace OpenNest.Engine.Fill
         {
             for (var i = 0; i < parts.Count; i++)
             {
-                if (candidate.Intersects(parts[i], out _))
+                if (!candidate.Intersects(parts[i], out _))
+                    continue;
+
+                // Part.Intersects compares outer perimeters only. A valid insert in a
+                // cutout must remain an obstacle, not be discarded as already overlapping.
+                var a = new ShapeProfile(PartGeometry.GetPartEntities(candidate));
+                var b = new ShapeProfile(PartGeometry.GetPartEntities(parts[i]));
+                if (a.Cutouts.Count == 0 && b.Cutouts.Count == 0)
+                    return true;
+                if (Collision.HasOverlap(
+                    a.Perimeter.ToPolygonWithTolerance(0.001),
+                    b.Perimeter.ToPolygonWithTolerance(0.001),
+                    a.Cutouts.Select(hole => hole.ToPolygonWithTolerance(0.001)).ToList(),
+                    b.Cutouts.Select(hole => hole.ToPolygonWithTolerance(0.001)).ToList()))
                     return true;
             }
             return false;
         }
 
-        private static bool CanNudgeWithoutOverlap(Part moving, Part obstacle, Vector direction)
-        {
-            var nudge = direction * (Tolerance.Epsilon * 10);
-
-            moving.Offset(nudge);
-            try
-            {
-                return !moving.Intersects(obstacle, out _);
-            }
-            finally
-            {
-                moving.Offset(-nudge);
-            }
-        }
-
         public static double Push(
             List<Part> movingParts,
             List<Part> obstacleParts,

OpenNest.Engine/Fill/Expander.cs

@@ -0,0 +1,771 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Fill
+{
+    /// <summary>
+    /// Pushes a group of selected parts apart until every constrained pair
+    /// (selected↔selected and selected↔obstacle) reaches a target part-to-part
+    /// spacing, with the plate work area and all non-selected parts as hard
+    /// boundaries. The inverse of <see cref="Compactor"/>: it grows gaps instead
+    /// of closing them.
+    /// <para>
+    /// Input with overlaps is accepted: an overlapping pair is a pair with
+    /// negative clearance and is separated along the minimum-translation
+    /// direction. Moves are straight-line only — a pair that could separate only
+    /// by routing around a blocker is reported as a violation instead. Final
+    /// positions are always overlap-free; nothing moves off the work area.
+    /// </para>
+    /// <para>
+    /// Anchor policy: within a violated pair the later-indexed selected part
+    /// moves; the counterpart moves only as a fallback when the anchor mover is
+    /// fully blocked by a work-area edge. Walls (non-selected parts) never move.
+    /// </para>
+    /// </summary>
+    public static class Expander
+    {
+        public sealed class Options
+        {
+            /// <summary>First spacing probed by the search; also the floor for the doubling step.</summary>
+            public double InitialStep = 1.0;
+
+            /// <summary>Bisection stops once the achievable spacing is known within this tolerance.</summary>
+            public double Tolerance = 0.01;
+
+            /// <summary>Relaxation iteration cap per separation run.</summary>
+            public int MaxIterations = 100;
+
+            /// <summary>Upper bound for the spacing search. 0 = auto (work-area diagonal).</summary>
+            public double MaxSpacing = 0;
+        }
+
+        public sealed class Violation
+        {
+            public Part A;
+            public Part B;
+
+            /// <summary>Clearance actually reached (may be negative for unresolvable overlaps).</summary>
+            public double Achieved;
+
+            /// <summary>True when a work-area edge, not a part, blocked the last needed move.</summary>
+            public bool BlockedByEdge;
+        }
+
+        public sealed class Result
+        {
+            /// <summary>
+            /// Minimum part-to-part clearance the returned layout satisfies,
+            /// never below zero. 0 with violations means the layout was only
+            /// cleaned up as far as possible, not opened up.
+            /// </summary>
+            public double AchievedSpacing;
+
+            /// <summary>True when the run was cancelled; no positions were changed.</summary>
+            public bool Cancelled;
+
+            /// <summary>Pairs that could not reach <see cref="AchievedSpacing"/>.</summary>
+            public List<Violation> Violations = new();
+        }
+
+        /// <summary>
+        /// Raises the part-to-part spacing of the selection as far as the plate
+        /// and its other parts allow, applying the best spacing found. Plate
+        /// PartSpacing/EdgeSpacing are not modified; edges keep their own
+        /// EdgeSpacing floor while only part-to-part clearance chases the target.
+        /// Mutates <paramref name="selected"/> locations; probing never touches
+        /// them, so a failed or cancelled run leaves the layout unchanged.
+        /// </summary>
+        public static Result Expand(
+            List<Part> selected,
+            Plate plate,
+            Options options = null,
+            CancellationToken token = default
+        )
+        {
+            if (plate == null)
+                throw new ArgumentNullException(nameof(plate));
+            if (selected == null || selected.Count < 2)
+                throw new ArgumentException(
+                    "Expand requires at least two selected parts.",
+                    nameof(selected)
+                );
+            if (selected.Any(p => !plate.Parts.Contains(p)))
+                throw new ArgumentException(
+                    "All selected parts must belong to the plate.",
+                    nameof(selected)
+                );
+
+            var opt = options ?? new Options();
+            var context = SeparationContext.Prepare(selected, plate);
+            var entry = context.Positions(); // all parts; movers are [0, count)
+            var result = new Result();
+
+            var sMin = MinimumPairClearance(context, entry);
+            result.AchievedSpacing = System.Math.Max(0, sMin);
+
+            if (token.IsCancellationRequested)
+            {
+                result.Cancelled = true;
+                return result;
+            }
+
+            var sGood = sMin;
+            var cap = opt.MaxSpacing > 0 ? opt.MaxSpacing : context.SpacingCap;
+            double hi; // first spacing that failed; double.NaN = none yet
+
+            (bool Converged, List<Vector> Positions) Probe(double spacing)
+            {
+                var attempt = Separate(context, entry, spacing, opt.MaxIterations, token);
+                return (attempt.Converged, attempt.Positions);
+            }
+
+            // Doubling phase: commit every spacing that converges. The cap gets
+            // its own probe even when the step jumps past it, and no spacing is
+            // probed twice.
+            var s = System.Math.Max(opt.InitialStep, 2 * System.Math.Max(0, sGood));
+            hi = double.NaN;
+
+            while (true)
+            {
+                if (s > cap)
+                {
+                    if (cap > sGood + opt.Tolerance)
+                        s = cap;
+                    else
+                        break;
+                }
+
+                if (s <= sGood + opt.Tolerance)
+                    break;
+
+                if (token.IsCancellationRequested)
+                {
+                    result.Cancelled = true;
+                    return result;
+                }
+
+                var probe = Probe(s);
+
+                if (probe.Converged)
+                {
+                    sGood = s;
+                    if (sGood >= cap)
+                        break;
+                    s = System.Math.Max(s * 2, sGood + opt.Tolerance);
+                }
+                else
+                {
+                    hi = s;
+                    break;
+                }
+            }
+
+            // Bisection between the last spacing that converged and the first that failed.
+            if (!double.IsNaN(hi))
+            {
+                var lo = System.Math.Max(0, sGood);
+                while (hi - lo > opt.Tolerance)
+                {
+                    if (token.IsCancellationRequested)
+                    {
+                        result.Cancelled = true;
+                        return result;
+                    }
+
+                    var mid = (lo + hi) / 2;
+                    if (Probe(mid).Converged)
+                        lo = mid;
+                    else
+                        hi = mid;
+                }
+                sGood = lo;
+            }
+
+            // Finalize: re-separate at the applied spacing from the entry state.
+            // Deterministic, so this reproduces any committed probe exactly; when
+            // sGood was never probed (overlapping entry) it still performs the
+            // best-effort cleanup and yields the violation report.
+            var final = Separate(context, entry, System.Math.Max(0, sGood), opt.MaxIterations, token);
+
+            if (token.IsCancellationRequested)
+            {
+                result.Cancelled = true;
+                return result;
+            }
+
+            var positions = final.Positions;
+
+            Apply(selected, entry, positions);
+
+            var measured = MinimumPairClearance(context, positions);
+            result.AchievedSpacing = System.Math.Max(0, System.Math.Min(System.Math.Max(0, sGood), measured));
+            result.Violations = final.Violations;
+            return result;
+        }
+
+        /// <summary>
+        /// Relaxes the given parts apart to a fixed target spacing against the
+        /// plate. Works on scratch positions; the caller applies them. Exposed
+        /// for testing and for callers that manage their own spacing search.
+        /// </summary>
+        public static (bool Converged, List<Vector> Positions, List<Violation> Violations) Separate(
+            List<Part> selected,
+            Plate plate,
+            double spacing,
+            int maxIterations = 100,
+            CancellationToken token = default
+        )
+        {
+            var context = SeparationContext.Prepare(selected, plate);
+            var positions = context.Positions();
+            return Separate(context, positions, spacing, maxIterations, token);
+        }
+
+        private static void Apply(List<Part> selected, List<Vector> from, List<Vector> to)
+        {
+            // Only movers occupy [0, selected.Count); walls never move.
+            for (var i = 0; i < selected.Count; i++)
+            {
+                var delta = to[i] - from[i];
+                if (delta.X != 0 || delta.Y != 0)
+                    selected[i].Offset(delta);
+            }
+        }
+
+        private static double MinimumPairClearance(SeparationContext context, List<Vector> positions)
+        {
+            var min = double.MaxValue;
+
+            foreach (var pair in context.Pairs)
+            {
+                var (distance, _) = context.PairClearance(pair.IndexA, pair.IndexB, positions);
+                if (distance < min)
+                    min = distance;
+            }
+
+            return min == double.MaxValue ? 0 : min;
+        }
+
+        private static (bool Converged, List<Vector> Positions, List<Violation> Violations) Separate(
+            SeparationContext context,
+            List<Vector> start,
+            double spacing,
+            int maxIterations,
+            CancellationToken token
+        )
+        {
+            var positions = new List<Vector>(start);
+            var stuck = new HashSet<int>();
+            var violations = new List<Violation>();
+            var epsMove = 1e-4;
+
+            // Internal margin absorbs the clearance kernel's tessellation error so
+            // the applied spacing holds against the production validators.
+            var target = spacing + 0.002;
+
+            var iterationLimit = maxIterations < 1 ? 1 : maxIterations;
+
+            for (var iteration = 0; iteration < iterationLimit; iteration++)
+            {
+                if (token.IsCancellationRequested)
+                    return (false, start, violations);
+
+                var moved = 0.0;
+                var stuckChanged = false;
+
+                foreach (var pair in context.Pairs)
+                {
+                    if (stuck.Contains(pair.Id))
+                        continue;
+
+                    var (distance, directionA) = context.PairClearance(
+                        pair.IndexA,
+                        pair.IndexB,
+                        positions
+                    );
+
+                    // Trigger at the user spacing, not the internal margin: a
+                    // pair already at the requested spacing must not be nudged,
+                    // or feasible layouts at the ceiling (every pair exactly at
+                    // spacing) would oscillate forever. The margin only sets how
+                    // far past the trigger a push carries, absorbing tessellation
+                    // error in the measurement.
+                    if (distance >= spacing)
+                        continue;
+
+                    var need = target - distance;
+
+                    // Anchor policy (decided): only the later-indexed selected
+                    // part of a violated pair moves. Counterparts and walls
+                    // never do — a pair whose anchor mover cannot reach the
+                    // target is a violation, not an invitation to drift the
+                    // anchor.
+                    var moverIndex = pair.Mover;
+
+                    // Clearance direction translates A away from B; a mover on
+                    // the B side travels the opposite way.
+                    var direction = moverIndex == pair.IndexA ? directionA : -directionA;
+
+                    var room = context.ClipToWorkArea(
+                        moverIndex,
+                        positions[moverIndex],
+                        direction,
+                        need
+                    );
+
+                    // Take the largest valid step up to `room`: partial moves let
+                    // a blocked mover advance again once its own blockers move
+                    // away in later iterations (a wave separates a chain).
+                    var applied = 0.0;
+                    var blockedByEdge = false;
+
+                    if (room > 0)
+                    {
+                        var trial = positions[moverIndex] + direction * room;
+
+                        if (context.MaintainsValidity(moverIndex, trial, positions))
+                        {
+                            positions[moverIndex] = trial;
+                            applied = room;
+                        }
+                        else
+                        {
+                            var lo = 0.0;
+                            var hi2 = room;
+                            for (var bisect = 0; bisect < 24 && hi2 - lo > 1e-6; bisect++)
+                            {
+                                var mid = (lo + hi2) / 2;
+                                if (
+                                    context.MaintainsValidity(
+                                        moverIndex,
+                                        positions[moverIndex] + direction * mid,
+                                        positions
+                                    )
+                                )
+                                    lo = mid;
+                                else
+                                    hi2 = mid;
+                            }
+
+                            if (lo > epsMove)
+                            {
+                                positions[moverIndex] = positions[moverIndex] + direction * lo;
+                                applied = lo;
+                            }
+                        }
+
+                        blockedByEdge = applied < need - epsMove;
+                        moved += applied;
+                    }
+                    else
+                    {
+                        blockedByEdge = true;
+                    }
+
+                    // A pair fully separated to the user target (the internal margin
+                    // absorbs tessellation slack) is satisfied even if not to target.
+                    if (applied > 0)
+                    {
+                        var (finalDistance, _) = context.PairClearance(
+                            pair.IndexA,
+                            pair.IndexB,
+                            positions
+                        );
+                        if (finalDistance >= spacing)
+                            continue;
+                        // Partial progress: keep the pair live — its blockers may
+                        // move away in later iterations and unblock the rest.
+                        continue;
+                    }
+
+                    // Zero progress twice in a row parks the pair; the final sweep
+                    // re-measures everything, so mid-loop bookkeeping never lies.
+                    if (stuck.Contains(pair.Id))
+                        continue;
+
+                    stuck.Add(pair.Id);
+                    stuckChanged = true;
+                }
+
+                if (moved < epsMove && !stuckChanged)
+                    break;
+            }
+
+            // Honest verdict: stuck bookkeeping and the internal margin can both
+            // let a pair read as satisfied mid-loop while a later pair move
+            // un-does it (oscillation). Re-measure every constrained pair at the
+            // final positions once; the violations this sweep finds are the
+            // report, and any violation makes the run non-converged.
+            violations.Clear();
+            foreach (var pair in context.Pairs)
+            {
+                var (distance, _) = context.PairClearance(
+                    pair.IndexA,
+                    pair.IndexB,
+                    positions
+                );
+
+                if (distance >= spacing)
+                    continue;
+
+                violations.Add(
+                    new Violation
+                    {
+                        A = context.PartOf(pair.IndexA),
+                        B = context.PartOf(pair.IndexB),
+                        Achieved = distance,
+                        BlockedByEdge = stuck.Contains(pair.Id),
+                    }
+                );
+            }
+
+            return (violations.Count == 0, positions, violations);
+        }
+
+        /// <summary>One constrained part↔part pair with its anchor mover.</summary>
+        private sealed class Pair
+        {
+            public int Id;
+            public int IndexA;
+            public int IndexB;
+            public int Mover;
+        }
+
+        /// <summary>
+        /// Per-run prepared geometry. Rings are local-frame polygons (world = local
+        /// + scratch position), prepared once per distinct Program by reference,
+        /// mirroring <see cref="PartOverlapChecker"/>'s caching but translatable.
+        /// </summary>
+        private sealed class SeparationContext
+        {
+            private readonly List<Part> parts; // movers [0, moverCount) then walls
+            private readonly List<RingSet> shapes; // per part
+            private readonly Box[] localBoxes; // per part, local frame
+            private readonly int moverCount;
+            private readonly Box workArea;
+
+            public readonly List<Pair> Pairs = new();
+            public readonly double SpacingCap;
+
+            private sealed class RingSet
+            {
+                public Polygon Outer;
+                public List<Polygon> Rings = new(); // outer + cutout rings, local frame
+                public List<Polygon> Holes = new();
+            }
+
+            private SeparationContext(
+                List<Part> parts,
+                List<RingSet> shapes,
+                Box[] localBoxes,
+                int moverCount,
+                Box workArea,
+                double spacingCap
+            )
+            {
+                this.parts = parts;
+                this.shapes = shapes;
+                this.localBoxes = localBoxes;
+                this.moverCount = moverCount;
+                this.workArea = workArea;
+                SpacingCap = spacingCap;
+            }
+
+            public static SeparationContext Prepare(List<Part> selected, Plate plate)
+            {
+                var movers = new List<Part>(selected);
+                var walls = plate.Parts.Where(p => !movers.Contains(p)).ToList();
+
+                var parts = new List<Part>(movers.Count + walls.Count);
+                parts.AddRange(movers);
+                parts.AddRange(walls);
+
+                var programs = new Dictionary<CNC.Program, RingSet>(
+                    ReferenceEqualityComparer.Instance
+                );
+                var shapes = new List<RingSet>(parts.Count);
+                var localBoxes = new Box[parts.Count];
+
+                for (var i = 0; i < parts.Count; i++)
+                {
+                    shapes.Add(PrepareProgram(programs, parts[i].Program));
+                    localBoxes[i] = LocalBox(parts[i]);
+                }
+
+                var workArea = plate.WorkArea();
+                var spacingCap = System.Math.Sqrt(
+                    workArea.Length * workArea.Length + workArea.Width * workArea.Width
+                );
+
+                var context = new SeparationContext(
+                    parts,
+                    shapes,
+                    localBoxes,
+                    movers.Count,
+                    workArea,
+                    spacingCap
+                );
+                context.BuildPairs();
+                return context;
+            }
+
+            private static RingSet PrepareProgram(
+                Dictionary<CNC.Program, RingSet> programs,
+                CNC.Program program
+            )
+            {
+                if (programs.TryGetValue(program, out var existing))
+                    return existing;
+
+                var prepared = new RingSet();
+                var entities = ConvertProgram
+                    .ToGeometry(program)
+                    .Where(e => SpecialLayers.IsMaterial(e.Layer))
+                    .ToList();
+
+                if (entities.Count > 0)
+                {
+                    var profile = new ShapeProfile(entities);
+
+                    if (profile.Perimeter != null)
+                    {
+                        prepared.Outer = profile.Perimeter.ToPolygonWithTolerance(0.001);
+                        prepared.Rings.Add(prepared.Outer);
+
+                        foreach (var cutout in profile.Cutouts)
+                        {
+                            var hole = cutout.ToPolygonWithTolerance(0.001);
+                            prepared.Rings.Add(hole);
+                            prepared.Holes.Add(hole);
+                        }
+                    }
+                }
+
+                programs.Add(program, prepared);
+                return prepared;
+            }
+
+            private static Box LocalBox(Part part)
+            {
+                var box = part.BoundingBox;
+                return new Box(
+                    box.Left - part.Location.X,
+                    box.Bottom - part.Location.Y,
+                    box.Length,
+                    box.Width
+                );
+            }
+
+            private void BuildPairs()
+            {
+                var id = 0;
+
+                for (var a = 0; a < parts.Count; a++)
+                {
+                    for (var b = a + 1; b < parts.Count; b++)
+                    {
+                        var aMover = a < moverCount;
+                        var bMover = b < moverCount;
+
+                        if (!aMover && !bMover)
+                            continue;
+
+                        Pairs.Add(
+                            new Pair
+                            {
+                                Id = id++,
+                                IndexA = a,
+                                IndexB = b,
+                                // Anchor policy: the later-index mover moves.
+                                Mover = bMover ? b : a,
+                            }
+                        );
+                    }
+                }
+            }
+
+            public bool IsMover(int index) => index < moverCount;
+
+            public Part PartOf(int index) => parts[index];
+
+            /// <summary>Current world positions of every part in pair-index order.</summary>
+            public List<Vector> Positions() => parts.Select(p => p.Location).ToList();
+
+            /// <summary>
+            /// Signed material clearance between two parts at the given scratch
+            /// positions. Material overlap (Collision oracle with hole subtraction)
+            /// reports negative penetration through the outer rings; otherwise the
+            /// clearance is the minimum boundary distance over all ring pairs, so a
+            /// part inside another's cutout measures its true gap to the hole ring
+            /// instead of a bogus outer-ring penetration.
+            /// </summary>
+            public (double Distance, Vector Direction) PairClearance(
+                int indexA,
+                int indexB,
+                List<Vector> positions
+            )
+            {
+                var setA = shapes[indexA];
+                var setB = shapes[indexB];
+
+                if (setA.Outer == null || setB.Outer == null)
+                    return (0, new Vector(1, 0));
+
+                var offsetA = positions[indexA];
+                var offsetB = positions[indexB];
+
+                var outerA = CloneAt(setA.Outer, offsetA);
+                var outerB = CloneAt(setB.Outer, offsetB);
+
+                var holesA = setA.Holes.Count == 0 ? null : CloneAll(setA.Holes, offsetA);
+                var holesB = setB.Holes.Count == 0 ? null : CloneAll(setB.Holes, offsetB);
+
+                if (Collision.HasOverlap(outerA, outerB, holesA, holesB))
+                {
+                    var penetration = Clearance.Between(outerA, outerB);
+                    if (penetration.Distance < 0)
+                        return (penetration.Distance, penetration.Direction);
+                    // Hole subtraction resolved what the outers overlap: touching.
+                    return (0, penetration.Direction);
+                }
+
+                double best = double.MaxValue;
+                var bestDir = new Vector(1, 0);
+
+                foreach (var ringA in setA.Rings)
+                {
+                    var worldA = CloneAt(ringA, offsetA);
+
+                    foreach (var ringB in setB.Rings)
+                    {
+                        var worldB = CloneAt(ringB, offsetB);
+                        var clearance = Clearance.BoundaryDistance(worldA, worldB);
+
+                        if (clearance.Distance < best)
+                        {
+                            best = clearance.Distance;
+                            bestDir = clearance.Direction;
+                        }
+                    }
+                }
+
+                return (best, bestDir);
+            }
+
+            /// <summary>
+            /// Largest α ≤ need such that translating the part by direction·α keeps
+            /// its AABB inside the work area.
+            /// </summary>
+            public double ClipToWorkArea(int index, Vector position, Vector direction, double need)
+            {
+                var box = localBoxes[index];
+                var left = position.X + box.Left - workArea.Left;
+                var right = workArea.Right - (position.X + box.Right);
+                var bottom = position.Y + box.Bottom - workArea.Bottom;
+                var top = workArea.Top - (position.Y + box.Top);
+
+                var max = need;
+                if (direction.X > 0)
+                    max = System.Math.Min(max, right / direction.X);
+                else if (direction.X < 0)
+                    max = System.Math.Min(max, left / -direction.X);
+
+                if (direction.Y > 0)
+                    max = System.Math.Min(max, top / direction.Y);
+                else if (direction.Y < 0)
+                    max = System.Math.Min(max, bottom / -direction.Y);
+
+                return max < 0 ? 0 : max;
+            }
+
+            /// <summary>
+            /// True when the part at <paramref name="trial"/> stays inside the work
+            /// area and keeps no material overlap with any other part (Collision
+            /// oracle with hole subtraction, so part-in-cutout stays legal).
+            /// </summary>
+            public bool MaintainsValidity(int index, Vector trial, List<Vector> positions)
+            {
+                var box = localBoxes[index];
+                var movedBox = box.Translate(trial);
+
+                if (
+                    movedBox.Left < workArea.Left - 1e-9
+                    || movedBox.Right > workArea.Right + 1e-9
+                    || movedBox.Bottom < workArea.Bottom - 1e-9
+                    || movedBox.Top > workArea.Top + 1e-9
+                )
+                    return false;
+
+                var outer = shapes[index].Outer;
+                if (outer == null)
+                    return true;
+
+                var worldOuter = CloneAt(outer, trial);
+                var worldHoles = shapes[index].Holes.Count == 0
+                    ? null
+                    : CloneAll(shapes[index].Holes, trial);
+
+                for (var i = 0; i < parts.Count; i++)
+                {
+                    if (i == index)
+                        continue;
+
+                    var otherOuter = shapes[i].Outer;
+                    if (otherOuter == null)
+                        continue;
+
+                    if (!BoxOverlap(movedBox, localBoxes[i].Translate(positions[i]), 0.002))
+                        continue;
+
+                    var worldOther = CloneAt(otherOuter, positions[i]);
+                    var worldOtherHoles = shapes[i].Holes.Count == 0
+                        ? null
+                        : CloneAll(shapes[i].Holes, positions[i]);
+
+                    if (
+                        Collision.HasOverlap(
+                            worldOuter,
+                            worldOther,
+                            worldHoles,
+                            worldOtherHoles
+                        )
+                    )
+                        return false;
+                }
+
+                return true;
+            }
+
+            private static List<Polygon> CloneAll(List<Polygon> polygons, Vector offset)
+            {
+                var list = new List<Polygon>(polygons.Count);
+                foreach (var polygon in polygons)
+                    list.Add(CloneAt(polygon, offset));
+                return list;
+            }
+
+            /// <summary>Clone with world bounds applied — prepared rings are never mutated.</summary>
+            private static Polygon CloneAt(Polygon polygon, Vector offset)
+            {
+                var clone = (Polygon)polygon.Clone();
+                clone.UpdateBounds();
+                clone.Offset(offset);
+                return clone;
+            }
+
+            private static bool BoxOverlap(Box a, Box b, double slack)
+            {
+                return !(
+                    a.Right + slack < b.Left
+                    || b.Right + slack < a.Left
+                    || a.Top + slack < b.Bottom
+                    || b.Top + slack < a.Bottom
+                );
+            }
+        }
+    }
+}

OpenNest.Engine/Fill/FillExtents.cs

@@ -83,8 +83,9 @@ namespace OpenNest.Engine.Fill
 
             // Slide uses locations, not cached bounds; Offset already translates the box.
             // Slide part2 left toward part1.
-            var movingLines = boundary2.GetLines(part2.Location, PushDirection.Left);
+            // Keep complete loops so the shared kernel can classify tangential contacts.
-            var stationaryLines = boundary1.GetLines(part1.Location, PushDirection.Right);
+            var movingLines = boundary2.GetLines(part2.Location);
+            var stationaryLines = boundary1.GetLines(part1.Location);
             var dist = SpatialQuery.DirectionalDistance(
                 movingLines,
                 stationaryLines,
@@ -234,15 +235,9 @@ namespace OpenNest.Engine.Fill
             PushDirection direction
         )
         {
-            var opposite = SpatialQuery.OppositeDirection(direction);
-            var movingEdges = movingBoundary.GetEdges(direction);
-            var stationaryEdges = stationaryBoundary.GetEdges(opposite);
-
             return SpatialQuery.DirectionalDistance(
-                movingEdges,
+                movingBoundary.GetLines(movingLocation),
-                movingLocation,
+                stationaryBoundary.GetLines(stationaryLocation),
-                stationaryEdges,
-                stationaryLocation,
                 direction
             );
         }

OpenNest.Engine/Jobs/Adapters/NestResultBinder.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Jobs.Adapters;
+
+/// <summary>
+/// Binds one result sheet's poses to the caller's own drawings. The pose semantics match
+/// <see cref="NestResultMaterializer"/>: rotate about the snapshot origin, then translate.
+/// Every pose must be finite and refer to a mapped drawing. Malformed sheets are rejected
+/// before binding any parts; the pipeline reports these violations without invoking binding.
+/// </summary>
+public static class NestResultBinder
+{
+    public static IReadOnlyList<Part> Bind(
+        NestJobPlateResult sheet,
+        IReadOnlyDictionary<string, Drawing> drawingsByPartId
+    )
+    {
+        ArgumentNullException.ThrowIfNull(sheet);
+        ArgumentNullException.ThrowIfNull(drawingsByPartId);
+        foreach (var pose in sheet.Placements)
+        {
+            if (pose.PartId == null || !drawingsByPartId.TryGetValue(pose.PartId, out var drawing) || drawing == null)
+                throw new ArgumentException("Result contains a requirement not present in the drawing map.", nameof(sheet));
+            if (!double.IsFinite(pose.X) || !double.IsFinite(pose.Y) || !double.IsFinite(pose.Rotation))
+                throw new ArgumentException("Result contains a nonfinite placement pose.", nameof(sheet));
+        }
+        var parts = new List<Part>(sheet.Placements.Count);
+        foreach (var pose in sheet.Placements)
+        {
+            var part = new Part(drawingsByPartId[pose.PartId]);
+            part.Rotate(pose.Rotation);
+            part.Location = new Vector(pose.X, pose.Y);
+            part.UpdateBounds();
+            parts.Add(part);
+        }
+        return parts;
+    }
+}

OpenNest.Engine/Jobs/NestLayoutCheck.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using OpenNest.Converters;
@@ -20,20 +21,77 @@ namespace OpenNest.Engine.Jobs;
 /// </summary>
 public static class NestLayoutCheck
 {
-    /// <summary>Checks bounds, spacing, quantities, offered stock and rotation policies.
+    /// <summary>Checks placement structure, bounds, spacing, quantities, offered stock,
+    /// MaxPlates and rotation policies. Unrepresentable placements skip geometry checks.
     /// Requirement IDs are used in messages. Instance indices and fulfillment metadata are
     /// not checked, matching the benchmark contract.</summary>
     public static IReadOnlyList<string> Violations(NestJob job, NestJobResult result)
+    {
+        ArgumentNullException.ThrowIfNull(job);
+        return Violations(job, result, job.Parts.ToDictionary(p => p.Id, p => p.Id));
+    }
+
+    /// <summary>Same checks as <see cref="Violations(NestJob, NestJobResult)"/>, with messages
+    /// naming each requirement by <paramref name="displayNames"/> (requirement ID -> name).</summary>
+    public static IReadOnlyList<string> Violations(
+        NestJob job,
+        NestJobResult result,
+        IReadOnlyDictionary<string, string> displayNames
+    ) => Violations(job, result, displayNames, out _);
+
+    internal static IReadOnlyList<string> Violations(
+        NestJob job,
+        NestJobResult result,
+        IReadOnlyDictionary<string, string> displayNames,
+        out bool canKeep
+    )
+    {
+        ArgumentNullException.ThrowIfNull(job);
+        ArgumentNullException.ThrowIfNull(result);
+        ArgumentNullException.ThrowIfNull(displayNames);
+        var violations = new List<string>();
+        ValidateStructure(job, result, displayNames, violations);
+        canKeep = violations.Count == 0;
+        if (canKeep)
         {
             var materialized = NestResultMaterializer.Materialize(job, result);
             var requirements = job.Parts.ToDictionary(p => materialized.DrawingsByPartId[p.Id],
-            p => (p.Id, p.Quantity));
+                p => (Name: displayNames.GetValueOrDefault(p.Id, p.Id), p.Quantity));
             var runs = materialized.Nest.Plates.Select(p => (p, p.Parts.ToList())).ToList();
-        var violations = Validate(runs, requirements);
+            violations.AddRange(Validate(runs, requirements));
-        ValidateAgainstJob(job, result, job.Parts.ToDictionary(p => p.Id, p => p.Id), violations);
+        }
+        ValidateAgainstJob(job, result, job.Parts.ToDictionary(p => p.Id,
+            p => displayNames.GetValueOrDefault(p.Id, p.Id)), violations);
         return violations;
     }
 
+    private static void ValidateStructure(
+        NestJob job,
+        NestJobResult result,
+        IReadOnlyDictionary<string, string> displayNames,
+        List<string> violations
+    )
+    {
+        var partIds = job.Parts.Select(p => p.Id).ToHashSet(StringComparer.Ordinal);
+        foreach (var sheet in result.Plates)
+        {
+            for (var i = 0; i < sheet.Placements.Count; i++)
+            {
+                var pose = sheet.Placements[i];
+                var name = pose.PartId == null ? "<null>" : displayNames.GetValueOrDefault(pose.PartId, pose.PartId);
+                var description = $"Plate {sheet.PlateIndex} placement {i} for '{name}'";
+                if (pose.PartId == null || !partIds.Contains(pose.PartId))
+                    violations.Add($"{description}, which is not part of this job");
+                if (!double.IsFinite(pose.X))
+                    violations.Add($"{description} has nonfinite X ({pose.X})");
+                if (!double.IsFinite(pose.Y))
+                    violations.Add($"{description} has nonfinite Y ({pose.Y})");
+                if (!double.IsFinite(pose.Rotation))
+                    violations.Add($"{description} has nonfinite Rotation ({pose.Rotation})");
+            }
+        }
+    }
+
     /// <summary>Tests material clearance using the benchmark's conservative outlines.
     /// The leftmost raw outline is inflated, matching the full-layout sweep; ties retain
     /// argument order. Geometry is cloned before transformation.</summary>
@@ -104,7 +162,7 @@ public static class NestLayoutCheck
     /// Checks what the materialized layout cannot show: every sheet must be
     /// one of the job's own stock entries (an engine may not invent a sheet
     /// size or loosen its spacing/edge settings, which the layout checks
-    /// would otherwise trust), finite stock may not be overdrawn, and every
+    /// would otherwise trust), finite stock and MaxPlates may not be overdrawn, and every
     /// placement's rotation must satisfy its part's RotationPolicy.
     /// </summary>
     internal static void ValidateAgainstJob(
@@ -118,6 +176,9 @@ public static class NestLayoutCheck
         var partsById = job.Parts.ToDictionary(p => p.Id);
         var sheetsUsed = new Dictionary<string, int>();
 
+        if (job.Options.MaxPlates is int maxPlates && jobResult.Plates.Count > maxPlates)
+            result.Add($"Used {jobResult.Plates.Count} sheet(s) but the job MaxPlates limit is {maxPlates}");
+
         foreach (var sheet in jobResult.Plates)
         {
             if (
@@ -150,8 +211,10 @@ public static class NestLayoutCheck
         {
             foreach (var placement in sheet.Placements)
             {
-                if (!partsById.TryGetValue(placement.PartId, out var part))
+                if (placement.PartId == null
-                    continue; // reported by ValidateQuantities
+                    || !partsById.TryGetValue(placement.PartId, out var part)
+                    || !double.IsFinite(placement.Rotation))
+                    continue; // reported by ValidateStructure
 
                 if (!part.Rotation.Allows(placement.Rotation))
                 {

OpenNest.Engine/Jobs/NestPipeline.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using OpenNest.Engine.Jobs.Adapters;
+
+namespace OpenNest.Engine.Jobs;
+
+/// <summary>
+/// One automatic-nesting request: the named engine, the caller's items (drawing, quantity,
+/// priority, rotation), the stock it may use, and optional job options. Items with a
+/// nonpositive quantity are skipped.
+/// </summary>
+public sealed record NestPipelineRequest(
+    string EngineName,
+    IReadOnlyList<NestItem> Items,
+    IReadOnlyList<NestPlateStock> Stock,
+    NestJobOptions Options = null
+);
+
+/// <summary>A proposed sheet: new parts bound by reference to the caller's drawings.</summary>
+public sealed record ProposedPlate(int PlateIndex, NestPlateStock Stock, IReadOnlyList<Part> Parts);
+
+/// <summary>
+/// The engine's raw result, its independent validation, and the proposed plates. Nothing
+/// has been committed; the caller decides what to do with an invalid result.
+/// </summary>
+public sealed class NestPipelineResult
+{
+    internal NestPipelineResult(
+        string engineName,
+        NestJob job,
+        NestJobResult raw,
+        IReadOnlyList<ProposedPlate> plates,
+        IReadOnlyList<string> violations,
+        bool canKeep,
+        TimeSpan solveTime,
+        TimeSpan validationTime
+    )
+    {
+        EngineName = engineName;
+        Job = job;
+        Raw = raw;
+        Plates = plates;
+        Violations = violations;
+        CanKeep = canKeep;
+        SolveTime = solveTime;
+        ValidationTime = validationTime;
+    }
+
+    public string EngineName { get; }
+    public NestJob Job { get; }
+    public NestJobResult Raw { get; }
+    public IReadOnlyList<ProposedPlate> Plates { get; }
+    public IReadOnlyList<string> Violations { get; }
+    public bool IsValid => Violations.Count == 0;
+    /// <summary>True when every placement can be represented, even if layout rules fail.
+    /// False for unknown/null requirement IDs or nonfinite poses; Plates is then empty.</summary>
+    public bool CanKeep { get; }
+    public NestJobStatus Status => Raw.Status;
+    public NestJobStopReason StopReason => Raw.StopReason;
+    public TimeSpan SolveTime { get; }
+    public TimeSpan ValidationTime { get; }
+}
+
+/// <summary>
+/// The single automatic-nesting path shared by every front end: build the job, solve it
+/// with the named engine, validate the result with the benchmark's rules, then bind
+/// placements to the caller's drawings. The pipeline never mutates caller items, drawings,
+/// or plates, and it does not care which engine is selected.
+/// </summary>
+public static class NestPipeline
+{
+    /// <summary>Resolves <see cref="NestPipelineRequest.EngineName"/> through
+    /// <see cref="NestingEngineRegistry"/>; unknown names throw <see cref="NotSupportedException"/>.
+    /// Engine cancellation propagates unchanged.</summary>
+    public static NestPipelineResult Run(
+        NestPipelineRequest request,
+        IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default
+    )
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        var engine = NestingEngineRegistry.Create(request.EngineName);
+        return Run(engine, request.EngineName, request, progress, token);
+    }
+
+    /// <summary>Runs a caller-supplied engine instance through the same validation and binding.</summary>
+    public static NestPipelineResult Run(
+        INestingEngine engine,
+        string engineName,
+        NestPipelineRequest request,
+        IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default
+    )
+    {
+        ArgumentNullException.ThrowIfNull(engine);
+        ArgumentNullException.ThrowIfNull(request);
+        ArgumentNullException.ThrowIfNull(request.Items);
+        ArgumentNullException.ThrowIfNull(request.Stock);
+        token.ThrowIfCancellationRequested();
+
+        var drawingsByPartId = new Dictionary<string, Drawing>(StringComparer.Ordinal);
+        var parts = new List<NestJobPart>();
+        for (var i = 0; i < request.Items.Count; i++)
+        {
+            var item = request.Items[i];
+            if (item == null || item.Quantity <= 0)
+                continue;
+            var partId = $"part-{i}";
+            parts.Add(DrawingJobMapper.FromItem(partId, item));
+            drawingsByPartId[partId] = item.Drawing;
+        }
+
+        var job = new NestJob(parts, request.Stock, request.Options);
+        NestJobValidator.Validate(job);
+
+        var clock = Stopwatch.StartNew();
+        var raw =
+            engine.Solve(job, progress, token)
+            ?? throw new InvalidOperationException($"Engine '{engineName}' returned no result.");
+        var solveTime = clock.Elapsed;
+        token.ThrowIfCancellationRequested();
+
+        clock.Restart();
+        var names = drawingsByPartId.ToDictionary(
+            kv => kv.Key,
+            kv => kv.Value.Name ?? kv.Key,
+            StringComparer.Ordinal
+        );
+        var violations = NestLayoutCheck.Violations(job, raw, names, out var canKeep);
+        var validationTime = clock.Elapsed;
+
+        var plates = canKeep
+            ? raw.Plates.Select(sheet => new ProposedPlate(
+                sheet.PlateIndex,
+                sheet.Stock,
+                NestResultBinder.Bind(sheet, drawingsByPartId)
+            ))
+            .ToList()
+            : new List<ProposedPlate>();
+
+        token.ThrowIfCancellationRequested();
+        return new NestPipelineResult(
+            engineName,
+            job,
+            raw,
+            plates,
+            violations,
+            canKeep,
+            solveTime,
+            validationTime
+        );
+    }
+}

OpenNest.Engine/Jobs/NestPipelineCommit.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace OpenNest.Engine.Jobs;
+
+/// <summary>Applies an explicitly accepted whole-job proposal to empty physical sheets only.
+/// Caller must keep the nest and its drawings stable from request construction through commit.</summary>
+public static class NestPipelineCommit
+{
+    public static IReadOnlyList<Plate> ApplyToEmptyPlates(
+        NestPipelineResult result,
+        PlateManager manager,
+        bool allowInvalid = false,
+        CancellationToken token = default
+    )
+    {
+        ArgumentNullException.ThrowIfNull(result);
+        ArgumentNullException.ThrowIfNull(manager);
+        token.ThrowIfCancellationRequested();
+        if (!result.CanKeep || (!result.IsValid && !allowInvalid))
+            throw new InvalidOperationException("The nesting result cannot be committed without a keepable layout and explicit consent to its violations.");
+
+        var applied = new List<Plate>();
+        // Commit is synchronous on the caller's owning thread. Cancellation is checked
+        // before mutation, not partway through attachment (which would leave half a job).
+        manager.BeginBatch();
+        try
+        {
+            foreach (var proposed in result.Plates)
+            {
+                if (proposed.Parts.Count == 0)
+                    continue;
+                var plate = manager.GetOrCreateEmpty();
+                plate.Size = proposed.Stock.Size;
+                plate.PartSpacing = proposed.Stock.PartSpacing;
+                plate.EdgeSpacing = proposed.Stock.EdgeSpacing;
+                plate.Quadrant = proposed.Stock.Quadrant;
+                plate.Quantity = 1;
+                plate.Parts.AddRange(proposed.Parts);
+                applied.Add(plate);
+            }
+        }
+        finally
+        {
+            manager.EndBatch();
+        }
+        return applied.AsReadOnly();
+    }
+}

OpenNest.Engine/Jobs/NestStockBuilder.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using OpenNest.Engine.Jobs.Adapters;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Jobs;
+
+/// <summary>Shared stock snapshots for whole-job front ends. Plate repeat count is not inventory.</summary>
+public static class NestStockBuilder
+{
+    public static IReadOnlyList<NestPlateStock> FromTemplate(
+        Plate template,
+        IReadOnlyList<PlateOption> options,
+        int? quantityPerOption = null
+    )
+    {
+        ArgumentNullException.ThrowIfNull(template);
+        if (options == null || options.Count == 0)
+            return new[] { DrawingJobMapper.FromPlate("plate", template, quantityPerOption) };
+
+        var stock = new List<NestPlateStock>(options.Count);
+        for (var i = 0; i < options.Count; i++)
+        {
+            var option = options[i];
+            ArgumentNullException.ThrowIfNull(option);
+            stock.Add(new NestPlateStock(
+                $"option-{i}",
+                new Size(option.Width, option.Length),
+                quantityPerOption,
+                template.PartSpacing,
+                template.EdgeSpacing,
+                template.Quadrant
+            ));
+        }
+        return stock.AsReadOnly();
+    }
+
+    /// <summary>Single-sheet callers may not silently create additional sheets.</summary>
+    public static IReadOnlyList<NestPlateStock> SinglePlate(Plate plate) =>
+        FromTemplate(plate, null, quantityPerOption: 1);
+}

OpenNest.Engine/Sequencing/PlateSequencing.cs

@@ -0,0 +1,102 @@
+using System.Collections.Generic;
+using System.Linq;
+using OpenNest.CNC.CuttingStrategy;
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest.Engine.Sequencing
+{
+    /// <summary>Applies a sequencer's exit-first route as the plate's cutting order.</summary>
+    public static class PlateSequencing
+    {
+        /// <summary>Sequences the plates present when the operation starts.</summary>
+        public static void ApplyAll(IEnumerable<Plate> plates, SequenceParameters parameters)
+        {
+            // Reordering parts can make PlateManager replace the trailing empty
+            // plate. Snapshot before applying so those events cannot invalidate
+            // enumeration of the nest's live plate collection.
+            foreach (var plate in plates.ToArray())
+                Apply(plate, parameters);
+        }
+
+        public static void Apply(Plate plate, SequenceParameters parameters)
+        {
+            var sequencer = PartSequencerFactory.Create(parameters);
+            var ordered = sequencer.Sequence(plate.Parts.ToList(), plate)
+                .Select(p => p.Part).Reverse().ToList();
+
+            // Enforce dependencies AFTER reversing the exit-first route. Checking
+            // the sequencer's output itself would invert the safety rule on apply.
+            var cutOrder = OrderCutOffsFirst(ordered, plate);
+            plate.Parts.Clear();
+            foreach (var part in cutOrder)
+                plate.Parts.Add(part);
+        }
+
+        private static List<Part> OrderCutOffsFirst(List<Part> ordered, Plate plate)
+        {
+            var cuts = ordered.Select((part, index) => (Part: part, Index: index))
+                .Where(item => item.Part.BaseDrawing.IsCutOff).ToList();
+            if (cuts.Count == 0)
+                return ordered;
+
+            var definitions = new Dictionary<Drawing, CutOff>(ReferenceEqualityComparer.Instance);
+            foreach (var cutOff in plate.CutOffs)
+                definitions[cutOff.Drawing] = cutOff;
+
+            var bounds = plate.BoundingBox(includeParts: false);
+            var emitted = new bool[ordered.Count];
+            var result = new List<Part>(ordered.Count);
+            for (var i = 0; i < ordered.Count; i++)
+            {
+                var part = ordered[i];
+                if (!part.BaseDrawing.IsCutOff)
+                {
+                    foreach (var cut in cuts)
+                    {
+                        if (emitted[cut.Index])
+                            continue;
+
+                        // An orphaned cutoff still must not follow potentially
+                        // crossed parts when its nominal span cannot be recovered.
+                        if (!definitions.TryGetValue(cut.Part.BaseDrawing, out var definition)
+                            || CrossesBounds(definition, part.BoundingBox, bounds))
+                        {
+                            result.Add(cut.Part);
+                            emitted[cut.Index] = true;
+                        }
+                    }
+                }
+
+                if (!emitted[i])
+                {
+                    result.Add(part);
+                    emitted[i] = true;
+                }
+            }
+
+            return result;
+        }
+
+        private static bool CrossesBounds(CutOff cutOff, Box part, Box plate)
+        {
+            var vertical = cutOff.Axis == CutOffAxis.Vertical;
+            var position = vertical ? cutOff.Position.X : cutOff.Position.Y;
+            var acrossMin = vertical ? part.Left : part.Bottom;
+            var acrossMax = vertical ? part.Right : part.Top;
+            var alongMin = vertical ? part.Bottom : part.Left;
+            var alongMax = vertical ? part.Top : part.Right;
+            var start = cutOff.StartLimit ?? (vertical ? plate.Bottom : plate.Left);
+            var end = cutOff.EndLimit ?? (vertical ? plate.Top : plate.Right);
+
+            // Use the nominal line, not its trimmed cutting segments (which
+            // deliberately skip the parts). Bounds conservatively include edge
+            // contacts and concave recesses; limits prevent unrelated dependencies
+            // beyond the cutoff's span. Negative coordinates need no special case.
+            return !(position < acrossMin - Tolerance.Epsilon
+                || position > acrossMax + Tolerance.Epsilon
+                || System.Math.Max(start, end) < alongMin - Tolerance.Epsilon
+                || System.Math.Min(start, end) > alongMax + Tolerance.Epsilon);
+        }
+    }
+}

OpenNest.FrontEnd.Tests/NestingPipelineTests.cs

@@ -0,0 +1,351 @@
+using System.Reflection;
+using OpenNest.Api;
+using OpenNest.CNC;
+using OpenNest.Engine.Jobs;
+using OpenNest.Geometry;
+using OpenNest.IO;
+using OpenNest.Mcp;
+using OpenNest.Mcp.Tools;
+
+namespace OpenNest.FrontEnd.Tests;
+
+[CollectionDefinition("FrontEndRegistry", DisableParallelization = true)]
+public class FrontEndRegistryCollection { }
+
+[Collection("FrontEndRegistry")]
+public class NestingPipelineTests : IDisposable
+{
+    private readonly string directory = Path.Combine(Path.GetTempPath(), "opennest-frontends-" + Guid.NewGuid());
+
+    public NestingPipelineTests() => Directory.CreateDirectory(directory);
+    public void Dispose() => Directory.Delete(directory, true);
+
+    private static Drawing Square()
+    {
+        var shape = new Shape();
+        shape.Entities.Add(new Line(new Vector(0, 0), new Vector(2, 0)));
+        shape.Entities.Add(new Line(new Vector(2, 0), new Vector(2, 2)));
+        shape.Entities.Add(new Line(new Vector(2, 2), new Vector(0, 2)));
+        shape.Entities.Add(new Line(new Vector(0, 2), new Vector(0, 0)));
+        return new Drawing("square", OpenNest.Converters.ConvertGeometry.ToProgram(shape));
+    }
+
+    private static NestSession Session(bool occupied = false)
+    {
+        var session = new NestSession { Nest = new Nest("fixture") };
+        session.Nest.Drawings.Add(Square());
+        var plate = session.Nest.CreatePlate();
+        plate.Size = new Size(20, 30);
+        plate.PartSpacing = 0.2;
+        plate.EdgeSpacing = new Spacing(0.5, 0.5, 0.5, 0.5);
+        plate.Quantity = 7;
+        if (occupied)
+            plate.Parts.Add(new Part(session.Nest.Drawings.Single()));
+        return session;
+    }
+
+    private static string Engine(Func<NestJob, CancellationToken, NestJobResult> solve)
+    {
+        var name = "FrontEnd-" + Guid.NewGuid();
+        NestingEngineRegistry.Register(name, "test", () => new Stub(solve));
+        return name;
+    }
+
+    private sealed class Stub(Func<NestJob, CancellationToken, NestJobResult> solve) : INestingEngine
+    {
+        public NestJobResult Solve(NestJob job, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default) => solve(job, token);
+    }
+
+    private static NestJobResult Result(NestJob job, string mode)
+    {
+        var poses = mode switch
+        {
+            "overlap" => new[] { new NestJobPlacement(job.Parts[0].Id, 0, 1, 1, 0), new NestJobPlacement(job.Parts[0].Id, 1, 1, 1, 0) },
+            "unknown" => new[] { new NestJobPlacement("ghost", 0, 1, 1, 0) },
+            "nan" => new[] { new NestJobPlacement(job.Parts[0].Id, 0, double.NaN, 1, 0) },
+            _ => new[] { new NestJobPlacement(job.Parts[0].Id, 0, 1, 1, 0) },
+        };
+        var sheets = mode == "empty" ? Array.Empty<NestJobPlateResult>()
+            : mode == "multi" ? new[] { new NestJobPlateResult(0, job.Plates[0], poses), new NestJobPlateResult(1, job.Plates[0], poses) }
+            : new[] { new NestJobPlateResult(0, job.Plates[0], poses) };
+        // Deliberately lying metadata: front ends must count actual poses.
+        return new NestJobResult(NestJobStatus.Complete, NestJobStopReason.Completed, sheets,
+            job.Parts.Select(p => new PartFulfillment(p.Id, p.Quantity, 999, 0)),
+            new[] { new StockUsage(job.Plates[0].Id, 999, 0) });
+    }
+
+    private static int RunConsole(params string[] args)
+    {
+        var method = Assembly.Load("OpenNest.Console").GetType("NestConsole")!
+            .GetMethod("Run", BindingFlags.Static | BindingFlags.Public)!;
+        return (int)method.Invoke(null, new object[] { args })!;
+    }
+
+    [Theory]
+    [InlineData("overlap", false, 2)]
+    [InlineData("overlap", true, 0)]
+    [InlineData("multi", true, 2)]
+    [InlineData("unknown", true, 2)]
+    [InlineData("nan", true, 2)]
+    public void Console_RefusesInvalidWithoutOverwritingUnlessFaithfullyKeepable(string mode, bool allow, int expected)
+    {
+        var input = Path.Combine(directory, "input.nest");
+        var output = Path.Combine(directory, "output.nest");
+        Assert.True(new NestWriter(Session(true).Nest).Write(input));
+        var original = File.ReadAllBytes(input);
+        File.WriteAllText(output, "must survive rejection");
+        var engine = Engine((job, _) => Result(job, mode));
+        var args = new List<string> { input, "--autonest", "--engine", engine, "--quantity", "2", "--output", output };
+        if (allow) args.Add("--allow-invalid");
+        Assert.Equal(expected, RunConsole(args.ToArray()));
+        Assert.Equal(original, File.ReadAllBytes(input));
+        if (expected == 2)
+            Assert.Equal("must survive rejection", File.ReadAllText(output));
+        else
+        {
+            var nest = new NestReader(output).Read();
+            Assert.Equal(2, nest.Plates[0].Parts.Count);
+            Assert.Equal(1, nest.Plates[0].Quantity);
+            Assert.Equal(2, nest.Drawings.Single().Quantity.Nested);
+        }
+    }
+
+    [Fact]
+    public void Console_EmptyResultDoesNotOverwriteOutputOrOriginal()
+    {
+        var input = Path.Combine(directory, "input.nest");
+        var output = Path.Combine(directory, "output.nest");
+        Assert.True(new NestWriter(Session(true).Nest).Write(input));
+        var original = File.ReadAllBytes(input);
+        File.WriteAllText(output, "keep existing output");
+        var engine = Engine((job, _) => Result(job, "empty"));
+        Assert.Equal(2, RunConsole(input, "--autonest", "--engine", engine, "--output", output));
+        Assert.Equal(original, File.ReadAllBytes(input));
+        Assert.Equal("keep existing output", File.ReadAllText(output));
+    }
+
+    [Fact]
+    public void Console_CancelledSolveDoesNotSave()
+    {
+        var input = Path.Combine(directory, "input.nest");
+        var output = Path.Combine(directory, "output.nest");
+        Assert.True(new NestWriter(Session(true).Nest).Write(input));
+        var engine = Engine((_, _) => throw new OperationCanceledException());
+        Assert.Equal(2, RunConsole(input, "--autonest", "--engine", engine, "--output", output));
+        Assert.False(File.Exists(output));
+    }
+
+    [Fact]
+    public void Console_KeepPartsOnOccupiedSheetRejectsBeforeSolve()
+    {
+        var input = Path.Combine(directory, "input.nest");
+        Assert.True(new NestWriter(Session(true).Nest).Write(input));
+        var original = File.ReadAllBytes(input);
+        var engine = Engine((_, _) => throw new Xunit.Sdk.XunitException("must not solve occupied stock"));
+        Assert.Equal(2, RunConsole(input, "--autonest", "--keep-parts", "--engine", engine));
+        Assert.Equal(original, File.ReadAllBytes(input));
+    }
+
+    [Fact]
+    public void Console_ValidCommitPreservesSettingsAndUsesOnePhysicalSheet()
+    {
+        var input = Path.Combine(directory, "input.nest");
+        var output = Path.Combine(directory, "output.nest");
+        Assert.True(new NestWriter(Session(true).Nest).Write(input));
+        var engine = Engine((job, _) =>
+        {
+            Assert.Equal(1, Assert.Single(job.Plates).Quantity);
+            return Result(job, "valid");
+        });
+        Assert.Equal(0, RunConsole(input, "--autonest", "--engine", engine, "--output", output));
+        var plate = Assert.Single(new NestReader(output).Read().Plates);
+        Assert.Single(plate.Parts);
+        Assert.Equal(1, plate.Quantity);
+        Assert.Equal(0.2, plate.PartSpacing);
+        Assert.Equal(new Spacing(0.5, 0.5, 0.5, 0.5), plate.EdgeSpacing);
+    }
+
+    [Theory]
+    [InlineData("overlap", false, false)]
+    [InlineData("overlap", true, true)]
+    [InlineData("multi", true, false)]
+    [InlineData("unknown", true, false)]
+    [InlineData("nan", true, false)]
+    [InlineData("valid", false, true)]
+    public void Mcp_OnlyCommitsFaithfulSingleSheet(string mode, bool allow, bool committed)
+    {
+        var session = Session();
+        var plate = session.GetPlate(0);
+        var engine = Engine((job, _) =>
+        {
+            Assert.Equal(1, Assert.Single(job.Plates).Quantity);
+            return Result(job, mode);
+        });
+        var tool = new NestingTools(session);
+        var result = CallMcp(tool, engine, allow);
+        if (committed)
+        {
+            Assert.NotEmpty(plate.Parts);
+            Assert.Equal(1, plate.Quantity);
+            Assert.All(plate.Parts, p => Assert.Same(session.Nest.Drawings.Single(), p.BaseDrawing));
+            Assert.Equal(plate.Parts.Count, session.Nest.Drawings.Single().Quantity.Nested);
+        }
+        else
+        {
+            Assert.Contains("Error", result);
+            Assert.Empty(plate.Parts);
+            Assert.Equal(7, plate.Quantity);
+        }
+        if (mode != "valid") Assert.Contains("Violation", result);
+    }
+
+    private static string CallMcp(NestingTools tool, string engine, bool allow = false, CancellationToken token = default)
+    {
+        // Reflection lets RED exercise the old implementation before optional parameters exist.
+        var method = typeof(NestingTools).GetMethod(nameof(NestingTools.AutoNestPlate))!;
+        var args = method.GetParameters().Select(p => p.Name switch
+        {
+            "plateIndex" => (object)0,
+            "drawingNames" => "square",
+            "quantities" => "2",
+            "engine" => engine,
+            "allow_invalid" => allow,
+            "cancellationToken" => token,
+            _ => p.DefaultValue,
+        }).ToArray();
+        try { return (string)method.Invoke(tool, args)!; }
+        catch (TargetInvocationException ex) when (ex.InnerException is OperationCanceledException)
+        { throw ex.InnerException; }
+    }
+
+    [Fact]
+    public void Mcp_OccupiedSheetRejectsBeforeSolve()
+    {
+        var session = Session(true);
+        var original = session.GetPlate(0).Parts[0];
+        var engine = Engine((_, _) => throw new Xunit.Sdk.XunitException("must not solve occupied stock"));
+        Assert.Contains("occupied", CallMcp(new NestingTools(session), engine));
+        Assert.Same(original, Assert.Single(session.GetPlate(0).Parts));
+    }
+
+    [Fact]
+    public void Mcp_CancellationDoesNotCommit()
+    {
+        var session = Session();
+        using var cts = new CancellationTokenSource();
+        var engine = Engine((job, _) => { cts.Cancel(); return Result(job, "valid"); });
+        Assert.ThrowsAny<OperationCanceledException>(() => CallMcp(new NestingTools(session), engine, token: cts.Token));
+        Assert.Empty(session.GetPlate(0).Parts);
+    }
+
+    [Fact]
+    public void UnknownEngineDoesNotWriteOrCommit()
+    {
+        var session = Session();
+        Assert.Contains("unknown", CallMcp(new NestingTools(session), "missing-engine"), StringComparison.OrdinalIgnoreCase);
+        Assert.Empty(session.GetPlate(0).Parts);
+        var input = Path.Combine(directory, "input.nest");
+        var output = Path.Combine(directory, "output.nest");
+        Assert.True(new NestWriter(session.Nest).Write(input));
+        Assert.Equal(1, RunConsole(input, "--autonest", "--engine", "missing-engine", "--output", output));
+        Assert.False(File.Exists(output));
+    }
+
+    private NestRequest Request(string engine)
+    {
+        var path = Path.Combine(directory, "square.dxf");
+        Dxf.ExportProgram(Square().Program, path);
+        var request = new NestRequest
+        {
+            Parts = [new NestRequestPart { Id = "external-id", DxfPath = path, Quantity = 2, AllowRotation = false }],
+            Plates = [new NestRequestPlate { Id = "stock", Size = new Size(20, 30), Quantity = 1 }],
+        };
+        typeof(NestRequest).GetProperty("Engine")?.SetValue(request, engine);
+        return request;
+    }
+
+    [Theory]
+    [InlineData("valid", 1, "Valid")]
+    [InlineData("empty", 0, "Valid")]
+    [InlineData("overlap", 2, "Invalid")]
+    [InlineData("unknown", 0, "Unrepresentable")]
+    [InlineData("nan", 0, "Unrepresentable")]
+    public async Task Api_PluginSelectionDerivesCountsPreservesIdsAndReportsValidation(string mode, int placed, string validation)
+    {
+        var called = false;
+        var engine = Engine((job, _) => { called = true; return Result(job, mode); });
+        var response = await NestRunner.RunAsync(Request(engine));
+        Assert.True(called);
+        var fulfillment = Assert.Single(response.Fulfillment);
+        Assert.Equal("external-id", fulfillment.PartId);
+        Assert.Equal(placed, fulfillment.Placed);
+        Assert.Equal(2 - placed, fulfillment.Unplaced);
+        Assert.Equal(placed == 2 ? NestJobStatus.Complete : NestJobStatus.Incomplete, response.Status);
+        Assert.Equal(validation, typeof(NestResponse).GetProperty("ValidationStatus")?.GetValue(response)?.ToString());
+        Assert.Equal(placed > 0 ? 1 : 0, Assert.Single(response.StockUsage).Used);
+        Assert.Equal(placed, response.Nest.Plates.Sum(p => p.Parts.Count));
+        Assert.Equal("external-id", Assert.Single(response.Nest.Drawings).Name);
+        var archive = Path.Combine(directory, "result.nestquote");
+        await response.SaveAsync(archive);
+        var loaded = await NestResponse.LoadAsync(archive);
+        Assert.Equal(validation, typeof(NestResponse).GetProperty("ValidationStatus")?.GetValue(loaded)?.ToString());
+    }
+
+    [Fact]
+    public async Task Mcp_SessionGateSerializesCallsBeforeCheckingOccupiedTarget()
+    {
+        var session = Session();
+        var tool = new NestingTools(session);
+        var engine = Engine((job, _) => Result(job, "valid"));
+        using var gate = new SessionToolGate();
+        var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var first = gate.RunAsync(async token =>
+        {
+            entered.SetResult();
+            await release.Task;
+            return CallMcp(tool, engine, token: token);
+        }, CancellationToken.None).AsTask();
+        await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        var second = gate.RunAsync(token => new ValueTask<string>(CallMcp(tool, engine, token: token)),
+            CancellationToken.None).AsTask();
+        try
+        {
+            Assert.False(second.IsCompleted);
+        }
+        finally
+        {
+            release.TrySetResult();
+        }
+        Assert.Contains("success", await first.WaitAsync(TimeSpan.FromSeconds(5)));
+        Assert.Contains("occupied", await second.WaitAsync(TimeSpan.FromSeconds(5)));
+        Assert.Single(session.GetPlate(0).Parts);
+    }
+
+    [Fact]
+    public void Console_CancelledOrdinaryFillDoesNotOverwriteOutput()
+    {
+        var input = Path.Combine(directory, "input.nest");
+        var output = Path.Combine(directory, "output.nest");
+        Assert.True(new NestWriter(Session(true).Nest).Write(input));
+        File.WriteAllText(output, "existing output");
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        var run = Assembly.Load("OpenNest.Console").GetType("NestConsole")!
+            .GetMethod("RunCore", BindingFlags.Static | BindingFlags.NonPublic)!;
+        var error = Assert.Throws<TargetInvocationException>(() => run.Invoke(null,
+            new object[] { new[] { input, "--quantity", "1", "--output", output }, cts.Token }));
+        Assert.IsAssignableFrom<OperationCanceledException>(error.InnerException);
+        Assert.Equal("existing output", File.ReadAllText(output));
+    }
+
+    [Fact]
+    public async Task Api_UnknownEngineAndCancellationPropagate()
+    {
+        await Assert.ThrowsAsync<NotSupportedException>(() => NestRunner.RunAsync(Request("missing-engine")));
+        using var cts = new CancellationTokenSource();
+        var engine = Engine((job, _) => { cts.Cancel(); return Result(job, "valid"); });
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => NestRunner.RunAsync(Request(engine), token: cts.Token));
+    }
+}

OpenNest.FrontEnd.Tests/OpenNest.FrontEnd.Tests.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+    <Using Include="Xunit" />
+    <ProjectReference Include="../OpenNest.Console/OpenNest.Console.csproj" />
+    <ProjectReference Include="../OpenNest.Mcp/OpenNest.Mcp.csproj" />
+    <ProjectReference Include="../OpenNest.Api/OpenNest.Api.csproj" />
+  </ItemGroup>
+</Project>

OpenNest.Gpu/GpuSlideComputer.cs

@@ -1,8 +1,13 @@
+#nullable enable
+
 using System;
+using System.Collections.Generic;
 using ILGPU;
 using ILGPU.Algorithms;
 using ILGPU.Runtime;
 using OpenNest.Engine.BestFit;
+using OpenNest.Geometry;
+using OpenNest.Math;
 
 namespace OpenNest.Gpu
 {
@@ -19,7 +24,7 @@ namespace OpenNest.Gpu
             ArrayView1D<double, Stride1D.Dense>, // stationaryPrep
             ArrayView1D<double, Stride1D.Dense>, // movingPrep
             ArrayView1D<double, Stride1D.Dense>, // offsets
-            ArrayView1D<double, Stride1D.Dense>, // results
+            ArrayView1D<ContactWitness, Stride1D.Dense>, // results
             int,
             int,
             int
@@ -30,7 +35,7 @@ namespace OpenNest.Gpu
             ArrayView1D<double, Stride1D.Dense>, // stationaryPrep
             ArrayView1D<double, Stride1D.Dense>, // movingPrep
             ArrayView1D<double, Stride1D.Dense>, // offsets
-            ArrayView1D<double, Stride1D.Dense>, // results
+            ArrayView1D<ContactWitness, Stride1D.Dense>, // results
             ArrayView1D<int, Stride1D.Dense>, // directions
             int,
             int
@@ -47,22 +52,24 @@ namespace OpenNest.Gpu
 
         private MemoryBuffer1D<double, Stride1D.Dense>? _gpuStationaryRaw;
         private MemoryBuffer1D<double, Stride1D.Dense>? _gpuStationaryPrep;
-        private double[]? _lastStationaryData; // Keep CPU copy/ref for content check
+        private double[]? _lastStationaryData; // Active segment snapshot used for upload and contact topology
 
         private MemoryBuffer1D<double, Stride1D.Dense>? _gpuMovingRaw;
         private MemoryBuffer1D<double, Stride1D.Dense>? _gpuMovingPrep;
-        private double[]? _lastMovingData; // Keep CPU copy/ref for content check
+        private double[]? _lastMovingData; // Active segment snapshot used for upload and contact topology
 
         private MemoryBuffer1D<double, Stride1D.Dense>? _gpuOffsets;
-        private MemoryBuffer1D<double, Stride1D.Dense>? _gpuResults;
+        private MemoryBuffer1D<ContactWitness, Stride1D.Dense>? _gpuResults;
         private MemoryBuffer1D<int, Stride1D.Dense>? _gpuDirs;
         private int _offsetCapacity;
 
-        public GpuSlideComputer()
+        public GpuSlideComputer() : this(preferCPU: false) { }
+
+        public GpuSlideComputer(bool preferCPU)
         {
             _context = Context.CreateDefault();
             _accelerator = _context
-                .GetPreferredDevice(preferCPU: false)
+                .GetPreferredDevice(preferCPU)
                 .CreateAccelerator(_context);
 
             _kernel = _accelerator.LoadAutoGroupedStreamKernel<
@@ -70,7 +77,7 @@ namespace OpenNest.Gpu
                 ArrayView1D<double, Stride1D.Dense>,
                 ArrayView1D<double, Stride1D.Dense>,
                 ArrayView1D<double, Stride1D.Dense>,
-                ArrayView1D<double, Stride1D.Dense>,
+                ArrayView1D<ContactWitness, Stride1D.Dense>,
                 int,
                 int,
                 int
@@ -81,7 +88,7 @@ namespace OpenNest.Gpu
                 ArrayView1D<double, Stride1D.Dense>,
                 ArrayView1D<double, Stride1D.Dense>,
                 ArrayView1D<double, Stride1D.Dense>,
-                ArrayView1D<double, Stride1D.Dense>,
+                ArrayView1D<ContactWitness, Stride1D.Dense>,
                 ArrayView1D<int, Stride1D.Dense>,
                 int,
                 int
@@ -118,21 +125,24 @@ namespace OpenNest.Gpu
                 EnsureMoving(movingTemplateSegments, movingCount);
                 EnsureOffsetBuffers(offsetCount);
 
-                _gpuOffsets!.View.SubView(0, offsetCount * 2).CopyFromCPU(offsets);
+                _gpuOffsets!.View.SubView(0, offsetCount * 2).CopyFromCPU(
+                    _accelerator.DefaultStream, (ReadOnlySpan<double>)offsets.AsSpan(0, offsetCount * 2));
 
                 _kernel(
                     offsetCount,
                     _gpuStationaryPrep!.View,
                     _gpuMovingPrep!.View,
-                    _gpuOffsets.View,
+                    _gpuOffsets.View.SubView(0, offsetCount * 2),
-                    _gpuResults!.View,
+                    _gpuResults!.View.SubView(0, offsetCount),
                     stationaryCount,
                     movingCount,
                     (int)direction
                 );
 
                 _accelerator.Synchronize();
-                _gpuResults.View.SubView(0, offsetCount).CopyToCPU(results);
+                var witnesses = new ContactWitness[offsetCount];
+                _gpuResults.View.SubView(0, offsetCount).CopyToCPU(witnesses);
+                ResolveContacts(witnesses, offsets, results, direction, null);
             }
 
             return results;
@@ -161,93 +171,138 @@ namespace OpenNest.Gpu
                 EnsureMoving(movingTemplateSegments, movingCount);
                 EnsureOffsetBuffers(offsetCount);
 
-                _gpuOffsets!.View.SubView(0, offsetCount * 2).CopyFromCPU(offsets);
+                _gpuOffsets!.View.SubView(0, offsetCount * 2).CopyFromCPU(
-                _gpuDirs!.View.SubView(0, offsetCount).CopyFromCPU(directions);
+                    _accelerator.DefaultStream, (ReadOnlySpan<double>)offsets.AsSpan(0, offsetCount * 2));
+                _gpuDirs!.View.SubView(0, offsetCount).CopyFromCPU(
+                    _accelerator.DefaultStream, (ReadOnlySpan<int>)directions.AsSpan(0, offsetCount));
 
                 _kernelMultiDir(
                     offsetCount,
                     _gpuStationaryPrep!.View,
                     _gpuMovingPrep!.View,
-                    _gpuOffsets.View,
+                    _gpuOffsets.View.SubView(0, offsetCount * 2),
-                    _gpuResults!.View,
+                    _gpuResults!.View.SubView(0, offsetCount),
-                    _gpuDirs.View,
+                    _gpuDirs.View.SubView(0, offsetCount),
                     stationaryCount,
                     movingCount
                 );
 
                 _accelerator.Synchronize();
-                _gpuResults.View.SubView(0, offsetCount).CopyToCPU(results);
+                var witnesses = new ContactWitness[offsetCount];
+                _gpuResults.View.SubView(0, offsetCount).CopyToCPU(witnesses);
+                ResolveContacts(witnesses, offsets, results, default, directions);
             }
 
             return results;
         }
 
-        public void InvalidateStationary() => _lastStationaryData = null;
+        public void InvalidateStationary()
+        {
+            lock (_lock)
+                _lastStationaryData = null;
+        }
 
-        public void InvalidateMoving() => _lastMovingData = null;
+        public void InvalidateMoving()
+        {
+            lock (_lock)
+                _lastMovingData = null;
+        }
+
+        private void ResolveContacts(
+            ContactWitness[] witnesses,
+            double[] offsets,
+            double[] results,
+            PushDirection direction,
+            int[]? directions
+        )
+        {
+            var moving = default(List<Line>);
+            var stationary = default(List<Line>);
+            var contacts = default(SlideContactClassifier);
+            for (var i = 0; i < witnesses.Length; i++)
+            {
+                var witness = witnesses[i];
+                results[i] = witness.Distance;
+                if (witness.Distance == double.MaxValue)
+                    continue;
+
+                // GPU finds the nearest event. Prepare the complete boundaries only
+                // once per batch, and share their material-side topology at each offset.
+                if (contacts == null)
+                {
+                    moving = ToLines(_lastMovingData!);
+                    stationary = ToLines(_lastStationaryData!);
+                    contacts = SlideContactClassifier.FromLines(
+                        moving, Vector.Zero, stationary, Vector.Zero).Prepare();
+                }
+
+                var offset = new Vector(offsets[i * 2], offsets[i * 2 + 1]);
+                var push = directions == null ? direction : (PushDirection)directions[i];
+                var unit = SpatialQuery.DirectionToOffset(push, 1);
+                var placed = contacts.At(offset, Vector.Zero);
+                if (placed.Blocks(
+                    new Vector(witness.MovingX, witness.MovingY),
+                    new Vector(witness.StationaryX, witness.StationaryY), unit.X, unit.Y))
+                    continue;
+
+                // A departing or grazing event does not discard the obstacle: replay
+                // all events through the shared resolver to find the next blocking one,
+                // including another contact tied at the same distance.
+                results[i] = SpatialQuery.DirectionalDistance(
+                    moving!, offset.X, offset.Y, stationary!, push, placed);
+            }
+        }
+
+        private static List<Line> ToLines(double[] segments)
+        {
+            var lines = new List<Line>(segments.Length / 4);
+            for (var i = 0; i < segments.Length; i += 4)
+                lines.Add(new Line(segments[i], segments[i + 1], segments[i + 2], segments[i + 3]));
+            return lines;
+        }
 
         private void EnsureStationary(double[] data, int count)
         {
-            // Fast check: if same object or content is identical, skip upload
+            // Cache the active prefix by value: callers may reuse an array with a
-            if (
+            // different segment count or mutate its coordinates between batches.
-                _gpuStationaryPrep != null
+            var active = data.AsSpan(0, count * 4);
-                && _lastStationaryData != null
+            if (_gpuStationaryPrep != null && _lastStationaryData != null
-                && _lastStationaryData.Length == data.Length
+                && active.SequenceEqual(_lastStationaryData))
-            )
-            {
-                // Reference equality or content equality
-                if (
-                    _lastStationaryData == data
-                    || new ReadOnlySpan<double>(_lastStationaryData).SequenceEqual(
-                        new ReadOnlySpan<double>(data)
-                    )
-                )
-                {
                 return;
-                }
-            }
 
             _gpuStationaryRaw?.Dispose();
             _gpuStationaryPrep?.Dispose();
 
-            _gpuStationaryRaw = _accelerator.Allocate1D(data);
+            var snapshot = active.ToArray();
+            _gpuStationaryRaw = _accelerator.Allocate1D(snapshot);
             _gpuStationaryPrep = _accelerator.Allocate1D<double>(count * 10);
 
             _prepareKernel(count, _gpuStationaryRaw.View, _gpuStationaryPrep.View, count);
             _accelerator.Synchronize();
 
-            _lastStationaryData = data; // store reference for next comparison
+            _lastStationaryData = snapshot;
         }
 
         private void EnsureMoving(double[] data, int count)
         {
-            if (
+            // Cache the active prefix by value: callers may reuse an array with a
-                _gpuMovingPrep != null
+            // different segment count or mutate its coordinates between batches.
-                && _lastMovingData != null
+            var active = data.AsSpan(0, count * 4);
-                && _lastMovingData.Length == data.Length
+            if (_gpuMovingPrep != null && _lastMovingData != null
-            )
+                && active.SequenceEqual(_lastMovingData))
-            {
-                if (
-                    _lastMovingData == data
-                    || new ReadOnlySpan<double>(_lastMovingData).SequenceEqual(
-                        new ReadOnlySpan<double>(data)
-                    )
-                )
-                {
                 return;
-                }
-            }
 
             _gpuMovingRaw?.Dispose();
             _gpuMovingPrep?.Dispose();
 
-            _gpuMovingRaw = _accelerator.Allocate1D(data);
+            var snapshot = active.ToArray();
+            _gpuMovingRaw = _accelerator.Allocate1D(snapshot);
             _gpuMovingPrep = _accelerator.Allocate1D<double>(count * 10);
 
             _prepareKernel(count, _gpuMovingRaw.View, _gpuMovingPrep.View, count);
             _accelerator.Synchronize();
 
-            _lastMovingData = data;
+            _lastMovingData = snapshot;
         }
 
         private void EnsureOffsetBuffers(int offsetCount)
@@ -262,7 +317,7 @@ namespace OpenNest.Gpu
             _gpuDirs?.Dispose();
 
             _gpuOffsets = _accelerator.Allocate1D<double>(newCapacity * 2);
-            _gpuResults = _accelerator.Allocate1D<double>(newCapacity);
+            _gpuResults = _accelerator.Allocate1D<ContactWitness>(newCapacity);
             _gpuDirs = _accelerator.Allocate1D<int>(newCapacity);
 
             _offsetCapacity = newCapacity;
@@ -293,8 +348,8 @@ namespace OpenNest.Gpu
             var dy = y2 - y1;
 
             // invD is used for parameter 't'. We use a small epsilon for stability.
-            prepared[index * 10 + 4] = (XMath.Abs(dx) < 1e-9) ? 0 : 1.0 / dx;
+            prepared[index * 10 + 4] = (XMath.Abs(dx) < Tolerance.Epsilon) ? 0 : 1.0 / dx;
-            prepared[index * 10 + 5] = (XMath.Abs(dy) < 1e-9) ? 0 : 1.0 / dy;
+            prepared[index * 10 + 5] = (XMath.Abs(dy) < Tolerance.Epsilon) ? 0 : 1.0 / dy;
 
             prepared[index * 10 + 6] = XMath.Min(x1, x2);
             prepared[index * 10 + 7] = XMath.Max(x1, x2);
@@ -304,12 +359,48 @@ namespace OpenNest.Gpu
 
         // ── Main Slide Kernels ───────────────────────────────────────
 
+        // Public because ILGPU's CPU backend emits kernel argument types in a separate assembly.
+        public struct ContactWitness
+        {
+            public double Distance;
+            public double MovingX;
+            public double MovingY;
+            public double StationaryX;
+            public double StationaryY;
+        }
+
+        private static void Consider(
+            ref ContactWitness nearest,
+            double distance,
+            double vx,
+            double vy,
+            int rayDirection,
+            bool vertexMoves
+        )
+        {
+            var snapped = distance > Tolerance.Epsilon ? distance : 0;
+            if (snapped >= nearest.Distance)
+                return;
+
+            // Use the unsnapped hit for incidence; snapping a tiny gap to zero must
+            // not move the witness off the other boundary.
+            var dirX = rayDirection == 2 ? -1 : rayDirection == 3 ? 1 : 0;
+            var dirY = rayDirection == 0 ? 1 : rayDirection == 1 ? -1 : 0;
+            var hx = vx + distance * dirX;
+            var hy = vy + distance * dirY;
+            nearest.Distance = snapped;
+            nearest.MovingX = vertexMoves ? vx : hx;
+            nearest.MovingY = vertexMoves ? vy : hy;
+            nearest.StationaryX = vertexMoves ? hx : vx;
+            nearest.StationaryY = vertexMoves ? hy : vy;
+        }
+
         private static void SlideKernel(
             Index1D index,
             ArrayView1D<double, Stride1D.Dense> stationaryPrep,
             ArrayView1D<double, Stride1D.Dense> movingPrep,
             ArrayView1D<double, Stride1D.Dense> offsets,
-            ArrayView1D<double, Stride1D.Dense> results,
+            ArrayView1D<ContactWitness, Stride1D.Dense> results,
             int sCount,
             int mCount,
             int direction
@@ -337,7 +428,7 @@ namespace OpenNest.Gpu
             ArrayView1D<double, Stride1D.Dense> stationaryPrep,
             ArrayView1D<double, Stride1D.Dense> movingPrep,
             ArrayView1D<double, Stride1D.Dense> offsets,
-            ArrayView1D<double, Stride1D.Dense> results,
+            ArrayView1D<ContactWitness, Stride1D.Dense> results,
             ArrayView1D<int, Stride1D.Dense> directions,
             int sCount,
             int mCount
@@ -361,7 +452,7 @@ namespace OpenNest.Gpu
             );
         }
 
-        private static double ComputeSlideLean(
+        private static ContactWitness ComputeSlideLean(
             ArrayView1D<double, Stride1D.Dense> sPrep,
             ArrayView1D<double, Stride1D.Dense> mPrep,
             double dx,
@@ -371,20 +462,20 @@ namespace OpenNest.Gpu
             int direction
         )
         {
-            const double eps = 0.00001;
+            const double eps = Tolerance.Epsilon;
-            var minDist = double.MaxValue;
+            var nearest = new ContactWitness { Distance = double.MaxValue };
             var horizontal = direction >= 2;
             var oppDir = direction ^ 1;
 
             // ── Forward Pass: moving vertices vs stationary edges ─────
-            for (int i = 0; i < mCount; i++)
+            for (var i = 0; i < mCount; i++)
             {
                 var m1x = mPrep[i * 10 + 0] + dx;
                 var m1y = mPrep[i * 10 + 1] + dy;
                 var m2x = mPrep[i * 10 + 2] + dx;
                 var m2y = mPrep[i * 10 + 3] + dy;
 
-                for (int j = 0; j < sCount; j++)
+                for (var j = 0; j < sCount; j++)
                 {
                     var sMin = horizontal ? sPrep[j * 10 + 8] : sPrep[j * 10 + 6];
                     var sMax = horizontal ? sPrep[j * 10 + 9] : sPrep[j * 10 + 7];
@@ -394,8 +485,8 @@ namespace OpenNest.Gpu
                     if (mv1 >= sMin - eps && mv1 <= sMax + eps)
                     {
                         var d = RayEdgeLean(m1x, m1y, sPrep, j, direction, eps);
-                        if (d < minDist)
+                        Consider(ref nearest, d, m1x, m1y,
-                            minDist = d;
+                            direction, vertexMoves: true);
                     }
 
                     // Test moving vertex 2 against stationary edge j
@@ -403,21 +494,21 @@ namespace OpenNest.Gpu
                     if (mv2 >= sMin - eps && mv2 <= sMax + eps)
                     {
                         var d = RayEdgeLean(m2x, m2y, sPrep, j, direction, eps);
-                        if (d < minDist)
+                        Consider(ref nearest, d, m2x, m2y,
-                            minDist = d;
+                            direction, vertexMoves: true);
                     }
                 }
             }
 
             // ── Reverse Pass: stationary vertices vs moving edges ─────
-            for (int i = 0; i < sCount; i++)
+            for (var i = 0; i < sCount; i++)
             {
                 var s1x = sPrep[i * 10 + 0];
                 var s1y = sPrep[i * 10 + 1];
                 var s2x = sPrep[i * 10 + 2];
                 var s2y = sPrep[i * 10 + 3];
 
-                for (int j = 0; j < mCount; j++)
+                for (var j = 0; j < mCount; j++)
                 {
                     var mMin = horizontal ? (mPrep[j * 10 + 8] + dy) : (mPrep[j * 10 + 6] + dx);
                     var mMax = horizontal ? (mPrep[j * 10 + 9] + dy) : (mPrep[j * 10 + 7] + dx);
@@ -427,8 +518,8 @@ namespace OpenNest.Gpu
                     if (sv1 >= mMin - eps && sv1 <= mMax + eps)
                     {
                         var d = RayEdgeLeanMoving(s1x, s1y, mPrep, j, dx, dy, oppDir, eps);
-                        if (d < minDist)
+                        Consider(ref nearest, d, s1x, s1y,
-                            minDist = d;
+                            oppDir, vertexMoves: false);
                     }
 
                     // Test stationary vertex 2 against moving edge j
@@ -436,13 +527,13 @@ namespace OpenNest.Gpu
                     if (sv2 >= mMin - eps && sv2 <= mMax + eps)
                     {
                         var d = RayEdgeLeanMoving(s2x, s2y, mPrep, j, dx, dy, oppDir, eps);
-                        if (d < minDist)
+                        Consider(ref nearest, d, s2x, s2y,
-                            minDist = d;
+                            oppDir, vertexMoves: false);
                     }
                 }
             }
 
-            return minDist;
+            return nearest;
         }
 
         private static double RayEdgeLean(
@@ -472,9 +563,7 @@ namespace OpenNest.Gpu
                 var ix = p1x + t * (p2x - p1x);
                 var dist = (direction == 2) ? (vx - ix) : (ix - vx);
 
-                if (dist > eps)
+                return dist >= -eps ? dist : double.MaxValue;
-                    return dist;
-                return (dist >= -eps) ? 0.0 : double.MaxValue;
             }
             else // Vertical (Up=0, Down=1)
             {
@@ -489,9 +578,7 @@ namespace OpenNest.Gpu
                 var iy = p1y + t * (p2y - p1y);
                 var dist = (direction == 1) ? (vy - iy) : (iy - vy);
 
-                if (dist > eps)
+                return dist >= -eps ? dist : double.MaxValue;
-                    return dist;
-                return (dist >= -eps) ? 0.0 : double.MaxValue;
             }
         }
 
@@ -524,9 +611,7 @@ namespace OpenNest.Gpu
                 var ix = p1x + t * (p2x - p1x);
                 var dist = (direction == 2) ? (vx - ix) : (ix - vx);
 
-                if (dist > eps)
+                return dist >= -eps ? dist : double.MaxValue;
-                    return dist;
-                return (dist >= -eps) ? 0.0 : double.MaxValue;
             }
             else // Vertical
             {
@@ -541,9 +626,7 @@ namespace OpenNest.Gpu
                 var iy = p1y + t * (p2y - p1y);
                 var dist = (direction == 1) ? (vy - iy) : (iy - vy);
 
-                if (dist > eps)
+                return dist >= -eps ? dist : double.MaxValue;
-                    return dist;
-                return (dist >= -eps) ? 0.0 : double.MaxValue;
             }
         }
 

OpenNest.IO.Tests/CuttingParametersSerializerTests.cs

@@ -0,0 +1,408 @@
+using System.Text.Json;
+using OpenNest.CNC.CuttingStrategy;
+using CuttingParametersSerializer = OpenNest.IO.CuttingParametersSerializer;
+
+namespace OpenNest.IO.Tests;
+
+public class CuttingParametersSerializerTests
+{
+    [Theory]
+    [InlineData("None")]
+    [InlineData("Line")]
+    [InlineData("Arc")]
+    [InlineData("LineArc")]
+    [InlineData("CleanHole")]
+    [InlineData("LineLine")]
+    public void SettingsRoundTrip_PreservesEveryLeadInType(string type)
+    {
+        var leadIn = CreateLeadIn(type);
+        var original = new CuttingParameters
+        {
+            ExternalLeadIn = leadIn,
+            InternalLeadIn = leadIn,
+            ArcCircleLeadIn = leadIn,
+            TabConfig = new NormalTab { Size = 0.42, TabLeadIn = leadIn },
+        };
+
+        var restored = RoundTrip(original);
+
+        AssertEquivalent(leadIn, restored.ExternalLeadIn);
+        AssertEquivalent(leadIn, restored.InternalLeadIn);
+        AssertEquivalent(leadIn, restored.ArcCircleLeadIn);
+        AssertEquivalent(leadIn, restored.TabConfig.TabLeadIn);
+    }
+
+    [Theory]
+    [InlineData("None")]
+    [InlineData("Line")]
+    [InlineData("Arc")]
+    public void SettingsRoundTrip_PreservesEveryLeadOutType(string type)
+    {
+        var leadOut = CreateLeadOut(type);
+        var original = new CuttingParameters
+        {
+            ExternalLeadOut = leadOut,
+            InternalLeadOut = leadOut,
+            ArcCircleLeadOut = leadOut,
+            TabConfig = new NormalTab { Size = 0.42, TabLeadOut = leadOut },
+        };
+
+        var restored = RoundTrip(original);
+
+        AssertEquivalent(leadOut, restored.ExternalLeadOut);
+        AssertEquivalent(leadOut, restored.InternalLeadOut);
+        AssertEquivalent(leadOut, restored.ArcCircleLeadOut);
+        AssertEquivalent(leadOut, restored.TabConfig.TabLeadOut);
+    }
+
+    [Theory]
+    [InlineData("Normal")]
+    [InlineData("Machine")]
+    [InlineData("Breaker")]
+    public void SettingsRoundTrip_PreservesEveryTabType(string type)
+    {
+        var original = new CuttingParameters
+        {
+            TabsEnabled = true,
+            TabConfig = CreateTab(type),
+        };
+
+        AssertEquivalent(original, RoundTrip(original));
+    }
+
+    [Theory]
+    [InlineData(SequenceMethod.RightSide)]
+    [InlineData(SequenceMethod.LeastCode)]
+    [InlineData(SequenceMethod.Advanced)]
+    [InlineData(SequenceMethod.BottomSide)]
+    [InlineData(SequenceMethod.EdgeStart)]
+    [InlineData(SequenceMethod.LeftSide)]
+    [InlineData(SequenceMethod.RightSideAlt)]
+    public void SettingsRoundTrip_PreservesAllFieldsAndSequenceMethods(SequenceMethod method)
+    {
+        var original = CreateParameters();
+        original.Assignment.Method = method;
+        original.Sequencing.Method = method;
+
+        AssertEquivalent(original, RoundTrip(original));
+    }
+
+    [Fact]
+    public void Deserialize_LegacySettings_PreservesValuesAndUsesMissingFieldDefaults()
+    {
+        const string json = """
+            {
+              "externalLeadIn": { "type": "LineLine", "length1": 0.2, "angle1": 31,
+                                  "length2": 0.4, "angle2": 62 },
+              "externalLeadOut": { "type": "Line", "length": 0.5, "approachAngle": 43 },
+              "internalLeadIn": { "type": "Arc", "radius": 0.12 },
+              "internalLeadOut": { "type": "Arc", "radius": 0.09, "gapSize": 0 },
+              "arcCircleLeadIn": { "type": "CleanHole", "lineLength": 0.8,
+                                   "arcRadius": 0.3, "kerf": 0.04 },
+              "arcCircleLeadOut": { "type": "None" },
+              "tabsEnabled": true,
+              "tabWidth": 0.375,
+              "pierceClearance": 0.0625
+            }
+            """;
+
+        var restored = CuttingParametersSerializer.Deserialize(json);
+
+        var lineLine = Assert.IsType<LineLineLeadIn>(restored.ExternalLeadIn);
+        Assert.Equal(0.2, lineLine.Length1);
+        Assert.Equal(31, lineLine.ApproachAngle1);
+        Assert.Equal(0.4, lineLine.Length2);
+        Assert.Equal(62, lineLine.ApproachAngle2);
+        var lineOut = Assert.IsType<LineLeadOut>(restored.ExternalLeadOut);
+        Assert.Equal(0.5, lineOut.Length);
+        Assert.Equal(43, lineOut.ApproachAngle);
+        Assert.Equal(0.12, Assert.IsType<ArcLeadIn>(restored.InternalLeadIn).Radius);
+        Assert.Equal(0.09, Assert.IsType<ArcLeadOut>(restored.InternalLeadOut).Radius);
+        var cleanHole = Assert.IsType<CleanHoleLeadIn>(restored.ArcCircleLeadIn);
+        Assert.Equal(0.8, cleanHole.LineLength);
+        Assert.Equal(0.3, cleanHole.ArcRadius);
+        Assert.Equal(0.04, cleanHole.Kerf);
+        Assert.IsType<NoLeadOut>(restored.ArcCircleLeadOut);
+        Assert.True(restored.TabsEnabled);
+        Assert.Equal(0.375, Assert.IsType<NormalTab>(restored.TabConfig).Size);
+        Assert.Equal(0.0625, restored.PierceClearance);
+        Assert.False(restored.RoundLeadInAngles);
+        Assert.Equal(5, restored.LeadInAngleIncrement);
+        Assert.Equal(0, restored.AutoTabMinSize);
+        Assert.Equal(0, restored.AutoTabMaxSize);
+        AssertEquivalent(new AssignmentParameters(), restored.Assignment);
+        AssertEquivalent(new SequenceParameters(), restored.Sequencing);
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-1)]
+    public void Deserialize_LegacyNonpositiveAngleIncrement_UsesFiveDegrees(double increment)
+    {
+        var json = JsonSerializer.Serialize(new { leadInAngleIncrement = increment });
+
+        Assert.Equal(5, CuttingParametersSerializer.Deserialize(json).LeadInAngleIncrement);
+    }
+
+    [Fact]
+    public void Deserialize_EmptyObject_PreservesLegacyDefaults()
+    {
+        var restored = CuttingParametersSerializer.Deserialize("{}");
+
+        Assert.IsType<NoLeadIn>(restored.ExternalLeadIn);
+        Assert.IsType<NoLeadIn>(restored.InternalLeadIn);
+        Assert.IsType<NoLeadIn>(restored.ArcCircleLeadIn);
+        Assert.IsType<NoLeadOut>(restored.ExternalLeadOut);
+        Assert.IsType<NoLeadOut>(restored.InternalLeadOut);
+        Assert.IsType<NoLeadOut>(restored.ArcCircleLeadOut);
+        Assert.Equal(0, Assert.IsType<NormalTab>(restored.TabConfig).Size);
+        Assert.Equal(0, restored.PierceClearance);
+        Assert.Equal(5, restored.LeadInAngleIncrement);
+    }
+
+    [Fact]
+    public void Deserialize_JsonNull_ReturnsDomainDefaults()
+    {
+        AssertEquivalent(new CuttingParameters(), CuttingParametersSerializer.Deserialize("null"));
+    }
+
+    [Theory]
+    [InlineData("not-json")]
+    [InlineData("{\"externalLeadIn\":17}")]
+    public void Deserialize_MalformedSettings_ThrowsJsonException(string json)
+    {
+        Assert.Throws<JsonException>(() => CuttingParametersSerializer.Deserialize(json));
+    }
+
+    [Fact]
+    public void Deserialize_UnknownLeadTypes_UsesNoLead()
+    {
+        var restored = CuttingParametersSerializer.Deserialize("""
+            { "externalLeadIn": { "type": "FutureLead" },
+              "externalLeadOut": { "type": "FutureLead" } }
+            """);
+
+        Assert.IsType<NoLeadIn>(restored.ExternalLeadIn);
+        Assert.IsType<NoLeadOut>(restored.ExternalLeadOut);
+    }
+
+    [Fact]
+    public void SettingsRoundTrip_NullTab_PreservesLegacyWidthFallback()
+    {
+        var original = new CuttingParameters { TabConfig = null };
+        var json = CuttingParametersSerializer.Serialize(original);
+        using var document = JsonDocument.Parse(json);
+
+        Assert.Equal(0.25, document.RootElement.GetProperty("tabWidth").GetDouble());
+        Assert.DoesNotContain('\n', json);
+        Assert.Equal(0.25, Assert.IsType<NormalTab>(
+            CuttingParametersSerializer.Deserialize(json).TabConfig).Size);
+    }
+
+    [Theory]
+    [InlineData("Normal")]
+    [InlineData("Machine")]
+    [InlineData("Breaker")]
+    public void DtoRoundTrip_UsesNestJsonOptionsAndPreservesAllFields(string tabType)
+    {
+        var original = CreateParameters();
+        original.TabConfig = CreateTab(tabType);
+        original.LeadInAngleIncrement = 0;
+        var dto = CuttingParametersSerializer.ToDto(original);
+
+        var json = JsonSerializer.Serialize(dto, NestFormat.JsonOptions);
+        var parsed = JsonSerializer.Deserialize<CuttingParametersDto>(json, NestFormat.JsonOptions);
+        var restored = CuttingParametersSerializer.FromDto(parsed);
+
+        AssertEquivalent(original, restored);
+    }
+
+    [Fact]
+    public void DtoRoundTrip_NullParameters_RemainNull()
+    {
+        Assert.Null(CuttingParametersSerializer.ToDto(null));
+        Assert.Null(CuttingParametersSerializer.FromDto(null));
+    }
+
+    [Fact]
+    public void DtoRoundTrip_DefaultParameters_PreservesNullTab()
+    {
+        var original = new CuttingParameters();
+        var dto = CuttingParametersSerializer.ToDto(original);
+        var json = JsonSerializer.Serialize(dto, NestFormat.JsonOptions);
+        var parsed = JsonSerializer.Deserialize<CuttingParametersDto>(json, NestFormat.JsonOptions);
+
+        AssertEquivalent(original, CuttingParametersSerializer.FromDto(parsed));
+    }
+
+    [Fact]
+    public void DtoRoundTrip_NullAssignmentAndSequencing_RemainNull()
+    {
+        var original = new CuttingParameters { Assignment = null, Sequencing = null };
+        var dto = CuttingParametersSerializer.ToDto(original);
+        var json = JsonSerializer.Serialize(dto, NestFormat.JsonOptions);
+        var parsed = JsonSerializer.Deserialize<CuttingParametersDto>(json, NestFormat.JsonOptions);
+
+        AssertEquivalent(original, CuttingParametersSerializer.FromDto(parsed));
+    }
+
+    [Fact]
+    public void DtoMapping_SourceSnapshotAndRestoredParameters_AreIndependent()
+    {
+        var original = CreateParameters();
+        var dto = CuttingParametersSerializer.ToDto(original);
+        var restored = CuttingParametersSerializer.FromDto(dto);
+        AssertEquivalent(original, restored);
+
+        original.Assignment.Preference = "changed source";
+        original.Sequencing.SmallCutoutWidth = 101;
+        ((LineLineLeadIn)original.ExternalLeadIn).Length1 = 102;
+        ((BreakerTab)original.TabConfig).BreakerDepth = 103;
+        ((LineArcLeadIn)original.TabConfig.TabLeadIn).ArcRadius = 104;
+        ((ArcLeadOut)original.TabConfig.TabLeadOut).Radius = 105;
+        AssertEquivalent(CreateParameters(), CuttingParametersSerializer.FromDto(dto));
+
+        dto.Assignment.Preference = "changed snapshot";
+        dto.Sequencing.SmallCutoutWidth = 201;
+        dto.ExternalLeadIn.Length1 = 202;
+        dto.TabConfig.BreakerDepth = 203;
+        dto.TabConfig.TabLeadIn.ArcRadius = 204;
+        dto.TabConfig.TabLeadOut.Radius = 205;
+        AssertEquivalent(CreateParameters(), restored);
+    }
+
+    [Fact]
+    public void Deserialize_UnknownTabType_DoesNotInventACutStrategy()
+    {
+        var restored = CuttingParametersSerializer.Deserialize("""
+            { "tabConfig": { "type": "FutureTab" }, "tabWidth": 0.7 }
+            """);
+
+        Assert.Null(restored.TabConfig);
+    }
+
+    private static CuttingParameters RoundTrip(CuttingParameters original) =>
+        CuttingParametersSerializer.Deserialize(CuttingParametersSerializer.Serialize(original));
+
+    private static CuttingParameters CreateParameters() => new()
+    {
+        Id = 47,
+        MachineName = "Laser A",
+        MaterialName = "Steel",
+        Grade = "A36",
+        Thickness = 0.1875,
+        Kerf = 0.018,
+        PartSpacing = 0.23,
+        ExternalLeadIn = CreateLeadIn("LineLine"),
+        ExternalLeadOut = CreateLeadOut("Line"),
+        InternalLeadIn = CreateLeadIn("CleanHole"),
+        InternalLeadOut = CreateLeadOut("Arc"),
+        ArcCircleLeadIn = CreateLeadIn("LineArc"),
+        ArcCircleLeadOut = CreateLeadOut("None"),
+        PierceClearance = 0.17,
+        RoundLeadInAngles = true,
+        LeadInAngleIncrement = 13,
+        AutoTabMinSize = 0.62,
+        AutoTabMaxSize = 4.7,
+        TabConfig = CreateTab("Breaker"),
+        TabsEnabled = true,
+        Assignment = new AssignmentParameters
+        {
+            Method = SequenceMethod.EdgeStart,
+            Preference = "TAIL",
+            MinGeometryLength = 0.37,
+        },
+        Sequencing = new SequenceParameters
+        {
+            Method = SequenceMethod.LeftSide,
+            SmallCutoutWidth = 2.3,
+            SmallCutoutHeight = 3.4,
+            MediumCutoutWidth = 9.5,
+            MediumCutoutHeight = 10.6,
+            DistanceMediumSmall = 1.7,
+            AlternateRowsColumns = false,
+            AlternateCutoutsWithinRowColumn = false,
+            MinDistanceBetweenRowsColumns = 0.8,
+        },
+    };
+
+    private static LeadIn CreateLeadIn(string type) => type switch
+    {
+        "Line" => new LineLeadIn { Length = 0.37, ApproachAngle = 47 },
+        "Arc" => new ArcLeadIn { Radius = 0.53 },
+        "LineArc" => new LineArcLeadIn
+        {
+            LineLength = 0.43,
+            ArcRadius = 0.29,
+            ApproachAngle = 118,
+        },
+        "CleanHole" => new CleanHoleLeadIn { LineLength = 0.38, ArcRadius = 0.16, Kerf = 0.021 },
+        "LineLine" => new LineLineLeadIn
+        {
+            Length1 = 0.24,
+            ApproachAngle1 = 72,
+            Length2 = 0.48,
+            ApproachAngle2 = 36,
+        },
+        "None" => new NoLeadIn(),
+        _ => throw new ArgumentOutOfRangeException(nameof(type)),
+    };
+
+    private static LeadOut CreateLeadOut(string type) => type switch
+    {
+        "Line" => new LineLeadOut { Length = 0.21, ApproachAngle = 58 },
+        "Arc" => new ArcLeadOut { Radius = 0.19 },
+        "None" => new NoLeadOut(),
+        _ => throw new ArgumentOutOfRangeException(nameof(type)),
+    };
+
+    private static Tab CreateTab(string type)
+    {
+        var tab = type switch
+        {
+            "Normal" => (Tab)new NormalTab
+            {
+                CutoutMinWidth = 0.31,
+                CutoutMinHeight = 0.52,
+                CutoutMaxWidth = 3.7,
+                CutoutMaxHeight = 4.6,
+            },
+            "Machine" => new MachineTab { MachineTabId = 29 },
+            "Breaker" => new BreakerTab
+            {
+                BreakerDepth = 0.013,
+                BreakerLeadInLength = 0.09,
+                BreakerAngle = 26,
+            },
+            _ => throw new ArgumentOutOfRangeException(nameof(type)),
+        };
+        tab.Size = 0.41;
+        tab.TabLeadIn = CreateLeadIn("LineArc");
+        tab.TabLeadOut = CreateLeadOut("Arc");
+        return tab;
+    }
+
+    // Compare concrete runtime properties, including nested subtype fields, rather than
+    // using the serializer under test as the equality oracle. All model objects must be owned.
+    private static void AssertEquivalent(object? expected, object? actual)
+    {
+        if (expected == null)
+        {
+            Assert.Null(actual);
+            return;
+        }
+
+        Assert.NotNull(actual);
+        var type = expected.GetType();
+        Assert.Equal(type, actual.GetType());
+        if (type.IsValueType || expected is string)
+        {
+            Assert.Equal(expected, actual);
+            return;
+        }
+
+        Assert.NotSame(expected, actual);
+        foreach (var property in type.GetProperties())
+            AssertEquivalent(property.GetValue(expected), property.GetValue(actual));
+    }
+}

OpenNest.IO/CuttingParametersDto.cs

@@ -0,0 +1,97 @@
+using OpenNest.CNC.CuttingStrategy;
+
+namespace OpenNest.IO;
+
+/// <summary>
+/// JSON-safe cutting parameters shared by nest files and desktop settings.
+/// Lead and tab discriminators avoid serializing abstract domain types.
+/// </summary>
+public class CuttingParametersDto
+{
+    public int Id { get; set; }
+    public string MachineName { get; set; }
+    public string MaterialName { get; set; }
+    public string Grade { get; set; }
+    public double Thickness { get; set; }
+    public double Kerf { get; set; }
+    public double PartSpacing { get; set; }
+    public LeadInDto ExternalLeadIn { get; set; }
+    public LeadOutDto ExternalLeadOut { get; set; }
+    public LeadInDto InternalLeadIn { get; set; }
+    public LeadOutDto InternalLeadOut { get; set; }
+    public LeadInDto ArcCircleLeadIn { get; set; }
+    public LeadOutDto ArcCircleLeadOut { get; set; }
+    public bool TabsEnabled { get; set; }
+
+    // Legacy settings only stored tabWidth. A missing TabConfig uses that width;
+    // Type = "None" explicitly records a null tab in a nest parameter snapshot.
+    public double TabWidth { get; set; }
+    public TabDto TabConfig { get; set; }
+    public double PierceClearance { get; set; }
+    public bool RoundLeadInAngles { get; set; }
+    public double LeadInAngleIncrement { get; set; }
+    public double AutoTabMinSize { get; set; }
+    public double AutoTabMaxSize { get; set; }
+    public SequenceDto Sequencing { get; set; } = new();
+    public AssignmentDto Assignment { get; set; } = new();
+
+    public class LeadInDto
+    {
+        public string Type { get; set; } = "None";
+        public double Length { get; set; }
+        public double ApproachAngle { get; set; }
+        public double Radius { get; set; }
+        public double LineLength { get; set; }
+        public double ArcRadius { get; set; }
+        public double Kerf { get; set; }
+        public double Length1 { get; set; }
+        public double Angle1 { get; set; }
+        public double Length2 { get; set; }
+        public double Angle2 { get; set; }
+    }
+
+    public class LeadOutDto
+    {
+        public string Type { get; set; } = "None";
+        public double Length { get; set; }
+        public double ApproachAngle { get; set; }
+        public double Radius { get; set; }
+        public double GapSize { get; set; }
+    }
+
+    public class TabDto
+    {
+        public string Type { get; set; } = "None";
+        public double Size { get; set; }
+        public LeadInDto TabLeadIn { get; set; }
+        public LeadOutDto TabLeadOut { get; set; }
+        public double CutoutMinWidth { get; set; }
+        public double CutoutMinHeight { get; set; }
+        public double CutoutMaxWidth { get; set; }
+        public double CutoutMaxHeight { get; set; }
+        public int MachineTabId { get; set; }
+        public double BreakerDepth { get; set; }
+        public double BreakerLeadInLength { get; set; }
+        public double BreakerAngle { get; set; }
+    }
+
+    public class SequenceDto
+    {
+        public SequenceMethod Method { get; set; } = SequenceMethod.Advanced;
+        public double SmallCutoutWidth { get; set; } = 1.5;
+        public double SmallCutoutHeight { get; set; } = 1.5;
+        public double MediumCutoutWidth { get; set; } = 8.0;
+        public double MediumCutoutHeight { get; set; } = 8.0;
+        public double DistanceMediumSmall { get; set; }
+        public bool AlternateRowsColumns { get; set; } = true;
+        public bool AlternateCutoutsWithinRowColumn { get; set; } = true;
+        public double MinDistanceBetweenRowsColumns { get; set; } = 0.25;
+    }
+
+    public class AssignmentDto
+    {
+        public SequenceMethod Method { get; set; } = SequenceMethod.Advanced;
+        public string Preference { get; set; } = "ILAT";
+        public double MinGeometryLength { get; set; } = 0.01;
+    }
+}

OpenNest.IO/CuttingParametersSerializer.cs

@@ -0,0 +1,291 @@
+using System;
+using System.Text.Json;
+using OpenNest.CNC.CuttingStrategy;
+using static OpenNest.IO.CuttingParametersDto;
+
+namespace OpenNest.IO;
+
+public static class CuttingParametersSerializer
+{
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = false,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
+
+    /// <summary>Writes desktop settings, retaining the legacy null-tab width fallback.</summary>
+    public static string Serialize(CuttingParameters parameters)
+    {
+        ArgumentNullException.ThrowIfNull(parameters);
+        var dto = ToDto(parameters);
+        if (parameters.TabConfig == null)
+            dto.TabConfig = null;
+        return JsonSerializer.Serialize(dto, JsonOptions);
+    }
+
+    /// <summary>Reads desktop settings with their historical defaults and angle fallback.</summary>
+    public static CuttingParameters Deserialize(string json)
+    {
+        var dto = JsonSerializer.Deserialize<CuttingParametersDto>(json, JsonOptions);
+        var parameters = FromDto(dto) ?? new CuttingParameters();
+        if (parameters.LeadInAngleIncrement <= 0)
+            parameters.LeadInAngleIncrement = 5.0;
+        return parameters;
+    }
+
+    /// <summary>Captures an owned snapshot. Null stays null for absent plate parameters.</summary>
+    public static CuttingParametersDto ToDto(CuttingParameters parameters)
+    {
+        if (parameters == null)
+            return null;
+
+        return new CuttingParametersDto
+        {
+            Id = parameters.Id,
+            MachineName = parameters.MachineName,
+            MaterialName = parameters.MaterialName,
+            Grade = parameters.Grade,
+            Thickness = parameters.Thickness,
+            Kerf = parameters.Kerf,
+            PartSpacing = parameters.PartSpacing,
+            ExternalLeadIn = ToLeadInDto(parameters.ExternalLeadIn),
+            ExternalLeadOut = ToLeadOutDto(parameters.ExternalLeadOut),
+            InternalLeadIn = ToLeadInDto(parameters.InternalLeadIn),
+            InternalLeadOut = ToLeadOutDto(parameters.InternalLeadOut),
+            ArcCircleLeadIn = ToLeadInDto(parameters.ArcCircleLeadIn),
+            ArcCircleLeadOut = ToLeadOutDto(parameters.ArcCircleLeadOut),
+            TabsEnabled = parameters.TabsEnabled,
+            TabWidth = parameters.TabConfig?.Size ?? 0.25,
+            TabConfig = ToTabDto(parameters.TabConfig),
+            PierceClearance = parameters.PierceClearance,
+            RoundLeadInAngles = parameters.RoundLeadInAngles,
+            LeadInAngleIncrement = parameters.LeadInAngleIncrement,
+            AutoTabMinSize = parameters.AutoTabMinSize,
+            AutoTabMaxSize = parameters.AutoTabMaxSize,
+            Sequencing = ToSequenceDto(parameters.Sequencing),
+            Assignment = ToAssignmentDto(parameters.Assignment),
+        };
+    }
+
+    /// <summary>Restores an owned snapshot without the desktop settings' value normalization.</summary>
+    public static CuttingParameters FromDto(CuttingParametersDto dto)
+    {
+        if (dto == null)
+            return null;
+
+        return new CuttingParameters
+        {
+            Id = dto.Id,
+            MachineName = dto.MachineName,
+            MaterialName = dto.MaterialName,
+            Grade = dto.Grade,
+            Thickness = dto.Thickness,
+            Kerf = dto.Kerf,
+            PartSpacing = dto.PartSpacing,
+            ExternalLeadIn = FromLeadInDto(dto.ExternalLeadIn),
+            ExternalLeadOut = FromLeadOutDto(dto.ExternalLeadOut),
+            InternalLeadIn = FromLeadInDto(dto.InternalLeadIn),
+            InternalLeadOut = FromLeadOutDto(dto.InternalLeadOut),
+            ArcCircleLeadIn = FromLeadInDto(dto.ArcCircleLeadIn),
+            ArcCircleLeadOut = FromLeadOutDto(dto.ArcCircleLeadOut),
+            TabsEnabled = dto.TabsEnabled,
+            TabConfig = dto.TabConfig == null
+                ? new NormalTab { Size = dto.TabWidth }
+                : FromTabDto(dto.TabConfig),
+            PierceClearance = dto.PierceClearance,
+            RoundLeadInAngles = dto.RoundLeadInAngles,
+            LeadInAngleIncrement = dto.LeadInAngleIncrement,
+            AutoTabMinSize = dto.AutoTabMinSize,
+            AutoTabMaxSize = dto.AutoTabMaxSize,
+            Sequencing = FromSequenceDto(dto.Sequencing),
+            Assignment = FromAssignmentDto(dto.Assignment),
+        };
+    }
+
+    private static LeadInDto ToLeadInDto(LeadIn leadIn) => leadIn switch
+    {
+        LineLeadIn line => new LeadInDto
+        {
+            Type = "Line",
+            Length = line.Length,
+            ApproachAngle = line.ApproachAngle,
+        },
+        ArcLeadIn arc => new LeadInDto { Type = "Arc", Radius = arc.Radius },
+        LineArcLeadIn lineArc => new LeadInDto
+        {
+            Type = "LineArc",
+            LineLength = lineArc.LineLength,
+            ArcRadius = lineArc.ArcRadius,
+            ApproachAngle = lineArc.ApproachAngle,
+        },
+        CleanHoleLeadIn cleanHole => new LeadInDto
+        {
+            Type = "CleanHole",
+            LineLength = cleanHole.LineLength,
+            ArcRadius = cleanHole.ArcRadius,
+            Kerf = cleanHole.Kerf,
+        },
+        LineLineLeadIn lineLine => new LeadInDto
+        {
+            Type = "LineLine",
+            Length1 = lineLine.Length1,
+            Angle1 = lineLine.ApproachAngle1,
+            Length2 = lineLine.Length2,
+            Angle2 = lineLine.ApproachAngle2,
+        },
+        _ => new LeadInDto { Type = "None" },
+    };
+
+    private static LeadIn FromLeadInDto(LeadInDto dto) => dto?.Type switch
+    {
+        "Line" => new LineLeadIn { Length = dto.Length, ApproachAngle = dto.ApproachAngle },
+        "Arc" => new ArcLeadIn { Radius = dto.Radius },
+        "LineArc" => new LineArcLeadIn
+        {
+            LineLength = dto.LineLength,
+            ArcRadius = dto.ArcRadius,
+            ApproachAngle = dto.ApproachAngle,
+        },
+        "CleanHole" => new CleanHoleLeadIn
+        {
+            LineLength = dto.LineLength,
+            ArcRadius = dto.ArcRadius,
+            Kerf = dto.Kerf,
+        },
+        "LineLine" => new LineLineLeadIn
+        {
+            Length1 = dto.Length1,
+            ApproachAngle1 = dto.Angle1,
+            Length2 = dto.Length2,
+            ApproachAngle2 = dto.Angle2,
+        },
+        _ => new NoLeadIn(),
+    };
+
+    private static LeadOutDto ToLeadOutDto(LeadOut leadOut) => leadOut switch
+    {
+        LineLeadOut line => new LeadOutDto
+        {
+            Type = "Line",
+            Length = line.Length,
+            ApproachAngle = line.ApproachAngle,
+        },
+        ArcLeadOut arc => new LeadOutDto { Type = "Arc", Radius = arc.Radius },
+        _ => new LeadOutDto { Type = "None" },
+    };
+
+    private static LeadOut FromLeadOutDto(LeadOutDto dto) => dto?.Type switch
+    {
+        "Line" => new LineLeadOut { Length = dto.Length, ApproachAngle = dto.ApproachAngle },
+        "Arc" => new ArcLeadOut { Radius = dto.Radius },
+        _ => new NoLeadOut(),
+    };
+
+    private static TabDto ToTabDto(Tab tab)
+    {
+        var dto = tab switch
+        {
+            NormalTab normal => new TabDto
+            {
+                Type = "Normal",
+                CutoutMinWidth = normal.CutoutMinWidth,
+                CutoutMinHeight = normal.CutoutMinHeight,
+                CutoutMaxWidth = normal.CutoutMaxWidth,
+                CutoutMaxHeight = normal.CutoutMaxHeight,
+            },
+            MachineTab machine => new TabDto { Type = "Machine", MachineTabId = machine.MachineTabId },
+            BreakerTab breaker => new TabDto
+            {
+                Type = "Breaker",
+                BreakerDepth = breaker.BreakerDepth,
+                BreakerLeadInLength = breaker.BreakerLeadInLength,
+                BreakerAngle = breaker.BreakerAngle,
+            },
+            _ => new TabDto { Type = "None" },
+        };
+        if (tab != null)
+        {
+            dto.Size = tab.Size;
+            dto.TabLeadIn = tab.TabLeadIn == null ? null : ToLeadInDto(tab.TabLeadIn);
+            dto.TabLeadOut = tab.TabLeadOut == null ? null : ToLeadOutDto(tab.TabLeadOut);
+        }
+        return dto;
+    }
+
+    private static Tab FromTabDto(TabDto dto)
+    {
+        var tab = dto.Type switch
+        {
+            "Normal" => (Tab)new NormalTab
+            {
+                CutoutMinWidth = dto.CutoutMinWidth,
+                CutoutMinHeight = dto.CutoutMinHeight,
+                CutoutMaxWidth = dto.CutoutMaxWidth,
+                CutoutMaxHeight = dto.CutoutMaxHeight,
+            },
+            "Machine" => new MachineTab { MachineTabId = dto.MachineTabId },
+            "Breaker" => new BreakerTab
+            {
+                BreakerDepth = dto.BreakerDepth,
+                BreakerLeadInLength = dto.BreakerLeadInLength,
+                BreakerAngle = dto.BreakerAngle,
+            },
+            _ => null,
+        };
+        if (tab != null)
+        {
+            tab.Size = dto.Size;
+            tab.TabLeadIn = dto.TabLeadIn == null ? null : FromLeadInDto(dto.TabLeadIn);
+            tab.TabLeadOut = dto.TabLeadOut == null ? null : FromLeadOutDto(dto.TabLeadOut);
+        }
+        return tab;
+    }
+
+    private static SequenceDto ToSequenceDto(SequenceParameters parameters) => parameters == null
+        ? null
+        : new SequenceDto
+        {
+            Method = parameters.Method,
+            SmallCutoutWidth = parameters.SmallCutoutWidth,
+            SmallCutoutHeight = parameters.SmallCutoutHeight,
+            MediumCutoutWidth = parameters.MediumCutoutWidth,
+            MediumCutoutHeight = parameters.MediumCutoutHeight,
+            DistanceMediumSmall = parameters.DistanceMediumSmall,
+            AlternateRowsColumns = parameters.AlternateRowsColumns,
+            AlternateCutoutsWithinRowColumn = parameters.AlternateCutoutsWithinRowColumn,
+            MinDistanceBetweenRowsColumns = parameters.MinDistanceBetweenRowsColumns,
+        };
+
+    private static SequenceParameters FromSequenceDto(SequenceDto dto) => dto == null
+        ? null
+        : new SequenceParameters
+        {
+            Method = dto.Method,
+            SmallCutoutWidth = dto.SmallCutoutWidth,
+            SmallCutoutHeight = dto.SmallCutoutHeight,
+            MediumCutoutWidth = dto.MediumCutoutWidth,
+            MediumCutoutHeight = dto.MediumCutoutHeight,
+            DistanceMediumSmall = dto.DistanceMediumSmall,
+            AlternateRowsColumns = dto.AlternateRowsColumns,
+            AlternateCutoutsWithinRowColumn = dto.AlternateCutoutsWithinRowColumn,
+            MinDistanceBetweenRowsColumns = dto.MinDistanceBetweenRowsColumns,
+        };
+
+    private static AssignmentDto ToAssignmentDto(AssignmentParameters parameters) => parameters == null
+        ? null
+        : new AssignmentDto
+        {
+            Method = parameters.Method,
+            Preference = parameters.Preference,
+            MinGeometryLength = parameters.MinGeometryLength,
+        };
+
+    private static AssignmentParameters FromAssignmentDto(AssignmentDto dto) => dto == null
+        ? null
+        : new AssignmentParameters
+        {
+            Method = dto.Method,
+            Preference = dto.Preference,
+            MinGeometryLength = dto.MinGeometryLength,
+        };
+}

OpenNest.IO/NestFormat.cs

@@ -24,6 +24,8 @@ namespace OpenNest.IO
             public string DateLastModified { get; init; } = "";
             public string Notes { get; init; } = "";
             public string AssistGas { get; init; } = "";
+            public string Status { get; init; } = "Quote";
+            public string MadeBy { get; init; } = "";
             public double Thickness { get; init; }
             public MaterialDto Material { get; init; } = new();
             public PlateDefaultsDto PlateDefaults { get; init; } = new();
@@ -66,6 +68,7 @@ namespace OpenNest.IO
             public double PartSpacing { get; init; }
             public SpacingDto EdgeSpacing { get; init; } = new();
             public double GrainAngle { get; init; }
+            public CuttingParametersDto CuttingParameters { get; init; }
             public List<PartDto> Parts { get; init; } = new();
             public List<CutOffDto> CutOffs { get; init; } = new();
         }
@@ -78,6 +81,8 @@ namespace OpenNest.IO
             public double Rotation { get; init; }
             public bool HasManualLeadIns { get; init; }
             public bool LeadInsLocked { get; init; }
+            public string Program { get; init; }
+            public string DrawingHash { get; init; }
         }
 
         public record CutOffDto
@@ -87,6 +92,12 @@ namespace OpenNest.IO
             public string Axis { get; init; } = "vertical";
             public double? StartLimit { get; init; }
             public double? EndLimit { get; init; }
+
+            /// <summary>
+            /// Zero-based place in the plate's cut sequence (<c>Plate.Parts</c> order,
+            /// cut-offs included). Null in older files, which load it at the end.
+            /// </summary>
+            public int? Sequence { get; init; }
         }
 
         public record SizeDto

OpenNest.IO/NestReader.cs

@@ -18,6 +18,11 @@ namespace OpenNest.IO
     {
         private readonly Stream stream;
         private readonly ZipArchive zipArchive;
+        private readonly Dictionary<int, string> drawingHashes = new();
+        private readonly List<string> warnings = new();
+
+        /// <summary>Part programs that could not be restored; other parts still load.</summary>
+        public IReadOnlyList<string> Warnings => warnings.AsReadOnly();
 
         public NestReader(string file)
         {
@@ -63,33 +68,63 @@ namespace OpenNest.IO
             var programs = new Dictionary<int, Program>();
             for (var i = 1; i <= count; i++)
             {
-                var entry = zipArchive.GetEntry($"programs/program-{i}");
+                var name = $"programs/program-{i}";
-                if (entry == null)
+                if (zipArchive.GetEntry(name) == null)
                     continue;
-
+                programs[i] = ReadProgram(name, out var hash);
-                using var entryStream = entry.Open();
+                drawingHashes[i] = hash;
-                var memStream = new MemoryStream();
-                entryStream.CopyTo(memStream);
-                memStream.Position = 0;
-
-                var reader = new ProgramReader(memStream);
-                programs[i] = reader.Read();
-
-                // Read sub-programs if present
-                var subsEntry = zipArchive.GetEntry($"programs/program-{i}-subs");
-                if (subsEntry != null)
-                {
-                    using var subsStream = subsEntry.Open();
-                    ReadSubPrograms(programs[i], subsStream);
-                }
             }
             return programs;
         }
 
+        private Program ReadProgram(string name, out string hash)
+        {
+            var text = ReadEntry(name);
+            var subs = zipArchive.GetEntry(name + "-subs") == null ? "" : ReadEntry(name + "-subs");
+            hash = NestWriter.GetDrawingHash(text, subs);
+            using var programStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(text));
+            var program = new ProgramReader(programStream).Read();
+            if (subs.Length > 0)
+            {
+                using var subsStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(subs));
+                ReadSubPrograms(program, subsStream);
+            }
+            return program;
+        }
+
+        private void RestorePartProgram(Part part, PartDto dto, int plateId, int partIndex)
+        {
+            // Old files had only transient flags. They still load clean and silently.
+            if (string.IsNullOrEmpty(dto.Program))
+                return;
+
+            // A missing hash cannot establish that this program belongs to the current drawing.
+            if (!drawingHashes.TryGetValue(dto.DrawingId, out var hash)
+                || !string.Equals(dto.DrawingHash, hash, StringComparison.Ordinal))
+                return;
+
+            try
+            {
+                var program = ReadProgram(dto.Program, out _);
+                foreach (var call in program.Codes.OfType<SubProgramCall>())
+                    if (call.Program == null || !call.Program.Codes.Any(c => c is Motion))
+                        throw new InvalidDataException($"Missing or empty hole sub-program {call.Id}.");
+
+                if (!part.RestoreLeadInProgram(program, dto.LeadInsLocked))
+                    throw new InvalidDataException("The saved part program has no motion.");
+            }
+            catch (Exception ex) when (ex is IOException || ex is InvalidDataException || ex is FormatException
+                || ex is OverflowException || ex is ArgumentException || ex is InvalidOperationException)
+            {
+                warnings.Add($"Plate {plateId}, part {partIndex} ('{part.BaseDrawing.Name}'): "
+                    + $"could not restore '{dto.Program}'; loaded the clean drawing without lead-ins or tabs. {ex.Message}");
+            }
+        }
+
         private static void ReadSubPrograms(Program parent, Stream stream)
         {
             using var reader = new StreamReader(stream);
-            var currentId = -1;
+            var currentId = (int?)null;
             var lines = new List<string>();
 
             string line;
@@ -100,18 +135,18 @@ namespace OpenNest.IO
                 if (trimmed.StartsWith(":") && int.TryParse(trimmed.Substring(1), out var id))
                 {
                     // Flush previous sub-program
-                    if (currentId >= 0 && lines.Count > 0)
+                    if (currentId.HasValue && lines.Count > 0)
-                        parent.SubPrograms[currentId] = ParseSubProgram(lines);
+                        parent.SubPrograms[currentId.Value] = ParseSubProgram(lines);
 
                     currentId = id;
                     lines.Clear();
                 }
                 else if (trimmed == "M99")
                 {
-                    if (currentId >= 0 && lines.Count > 0)
+                    if (currentId.HasValue && lines.Count > 0)
-                        parent.SubPrograms[currentId] = ParseSubProgram(lines);
+                        parent.SubPrograms[currentId.Value] = ParseSubProgram(lines);
 
-                    currentId = -1;
+                    currentId = null;
                     lines.Clear();
                 }
                 else
@@ -306,6 +341,11 @@ namespace OpenNest.IO
             nest.DateLastModified = DateTime.Parse(dto.DateLastModified);
             nest.Notes = dto.Notes;
             nest.AssistGas = dto.AssistGas ?? "";
+            // Additive v2 fields: absent or unknown values keep the defaults.
+            nest.Status = Enum.TryParse<NestStatus>(dto.Status, true, out var status)
+                ? status
+                : NestStatus.Quote;
+            nest.MadeBy = dto.MadeBy ?? "";
 
             // Nest-level material and thickness (fall back to PlateDefaults for old files)
             var pd = dto.PlateDefaults;
@@ -357,21 +397,26 @@ namespace OpenNest.IO
                     p.EdgeSpacing.Top
                 );
                 plate.GrainAngle = p.GrainAngle;
+                plate.CuttingParameters = CuttingParametersSerializer.FromDto(p.CuttingParameters);
 
-                foreach (var partDto in p.Parts)
+                for (var partIndex = 0; partIndex < p.Parts.Count; partIndex++)
                 {
+                    var partDto = p.Parts[partIndex];
                     if (!drawingMap.TryGetValue(partDto.DrawingId, out var dwg))
                         continue;
 
                     var part = new Part(dwg);
                     part.Rotate(partDto.Rotation);
                     part.Offset(new Vector(partDto.X, partDto.Y));
+                    RestorePartProgram(part, partDto, p.Id, partIndex);
                     plate.Parts.Add(part);
                 }
 
                 // Cut-offs
                 if (p.CutOffs != null)
                 {
+                    var sequence = new Dictionary<CutOff, int>();
+
                     foreach (var cutoffDto in p.CutOffs)
                     {
                         var axis =
@@ -384,9 +429,12 @@ namespace OpenNest.IO
                             EndLimit = cutoffDto.EndLimit,
                         };
                         plate.CutOffs.Add(cutoff);
+
+                        if (cutoffDto.Sequence is int index)
+                            sequence[cutoff] = index;
                     }
 
-                    plate.RegenerateCutOffs(new CutOffSettings());
+                    plate.RegenerateCutOffs(new CutOffSettings(), sequence);
                 }
 
                 nest.Plates.Add(plate);

OpenNest.IO/NestWriter.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.IO.Compression;
 using System.Linq;
+using System.Security.Cryptography;
 using System.Text;
 using System.Text.Json;
 using OpenNest.CNC;
@@ -18,6 +20,8 @@ namespace OpenNest.IO
 
         private readonly Nest nest;
         private Dictionary<int, Drawing> drawingDict;
+        private readonly Dictionary<int, string> drawingHashes = new();
+        private readonly Dictionary<string, Program> partPrograms = new();
 
         public NestWriter(Nest nest)
         {
@@ -38,8 +42,12 @@ namespace OpenNest.IO
 
             using var zipArchive = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true);
 
-            WriteNestJson(zipArchive);
+            drawingHashes.Clear();
+            partPrograms.Clear();
             WritePrograms(zipArchive);
+            WriteNestJson(zipArchive);
+            foreach (var entry in partPrograms)
+                WriteProgramEntry(zipArchive, entry.Key, entry.Value);
             WriteEntities(zipArchive);
             WriteBestFits(zipArchive);
 
@@ -48,6 +56,7 @@ namespace OpenNest.IO
 
         private void SetDrawingIds()
         {
+            drawingDict.Clear();
             var id = 1;
             foreach (var drawing in nest.Drawings)
             {
@@ -79,6 +88,8 @@ namespace OpenNest.IO
                 DateLastModified = nest.DateLastModified.ToString("o"),
                 Notes = nest.Notes ?? "",
                 AssistGas = nest.AssistGas ?? "",
+                Status = nest.Status.ToString(),
+                MadeBy = nest.MadeBy ?? "",
                 Thickness = nest.Thickness,
                 Material = new MaterialDto
                 {
@@ -207,6 +218,11 @@ namespace OpenNest.IO
                     var match = drawingDict
                         .Where(dwg => dwg.Value == part.BaseDrawing)
                         .FirstOrDefault();
+                    var programName = part.HasManualLeadIns
+                        ? $"parts/plate-{id}/part-{parts.Count}"
+                        : null;
+                    if (programName != null)
+                        partPrograms.Add(programName, part.Program);
                     parts.Add(
                         new PartDto
                         {
@@ -216,6 +232,8 @@ namespace OpenNest.IO
                             Rotation = part.Rotation,
                             HasManualLeadIns = part.HasManualLeadIns,
                             LeadInsLocked = part.LeadInsLocked,
+                            Program = programName,
+                            DrawingHash = programName == null ? null : drawingHashes[match.Key],
                         }
                     );
                 }
@@ -223,6 +241,16 @@ namespace OpenNest.IO
                 var cutoffs = new List<CutOffDto>();
                 foreach (var cutoff in plate.CutOffs)
                 {
+                    var sequence = -1;
+                    for (var j = 0; j < plate.Parts.Count; j++)
+                    {
+                        if (ReferenceEquals(plate.Parts[j].BaseDrawing, cutoff.Drawing))
+                        {
+                            sequence = j;
+                            break;
+                        }
+                    }
+
                     cutoffs.Add(
                         new CutOffDto
                         {
@@ -231,6 +259,7 @@ namespace OpenNest.IO
                             Axis = cutoff.Axis == CutOffAxis.Vertical ? "vertical" : "horizontal",
                             StartLimit = cutoff.StartLimit,
                             EndLimit = cutoff.EndLimit,
+                            Sequence = sequence >= 0 ? sequence : null,
                         }
                     );
                 }
@@ -253,6 +282,7 @@ namespace OpenNest.IO
                         Parts = parts,
                         CutOffs = cutoffs,
                         GrainAngle = plate.GrainAngle,
+                        CuttingParameters = CuttingParametersSerializer.ToDto(plate.CuttingParameters),
                     }
                 );
             }
@@ -331,43 +361,44 @@ namespace OpenNest.IO
         private void WritePrograms(ZipArchive zipArchive)
         {
             foreach (var kvp in drawingDict.OrderBy(k => k.Key))
-            {
+                drawingHashes[kvp.Key] = WriteProgramEntry(
-                var name = $"programs/program-{kvp.Key}";
+                    zipArchive, $"programs/program-{kvp.Key}", kvp.Value.Program);
-                var stream = new MemoryStream();
+        }
-                WriteDrawing(stream, kvp.Value);
 
+        private static string WriteProgramEntry(ZipArchive zipArchive, string name, Program program)
+        {
+            var text = GetProgramText(program);
+            var subs = GetSubProgramsText(program);
+            WriteTextEntry(zipArchive, name, text);
+            if (subs.Length > 0)
+                WriteTextEntry(zipArchive, name + "-subs", subs);
+            return GetDrawingHash(text, subs);
+        }
+
+        private static void WriteTextEntry(ZipArchive zipArchive, string name, string text)
+        {
             var entry = zipArchive.CreateEntry(name);
-                using (var entryStream = entry.Open())
+            using var stream = entry.Open();
+            using var writer = new StreamWriter(stream, new UTF8Encoding(false));
+            writer.Write(text);
+        }
+
+        // Hash the exact saved text, including holes: a change to either invalidates the part.
+        internal static string GetDrawingHash(string text, string subs) =>
+            Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(
+                text.Length.ToString(CultureInfo.InvariantCulture) + ":" + text + subs)));
+
+        /// <summary>Serializes the hole programs using the same text as the nest archive.</summary>
+        public static string GetSubProgramsText(Program program)
         {
-                    stream.CopyTo(entryStream);
+            using var writer = new StringWriter(CultureInfo.InvariantCulture) { NewLine = "\n" };
-                }
+            foreach (var kvp in program.SubPrograms.OrderBy(k => k.Key))
-
-                // Write sub-programs if present
-                if (kvp.Value.Program.SubPrograms.Count > 0)
-                    WriteSubPrograms(zipArchive, kvp.Key, kvp.Value.Program.SubPrograms);
-            }
-        }
-
-        private void WriteSubPrograms(
-            ZipArchive zipArchive,
-            int drawingId,
-            Dictionary<int, Program> subPrograms
-        )
-        {
-            var entry = zipArchive.CreateEntry($"programs/program-{drawingId}-subs");
-            using var entryStream = entry.Open();
-            using var writer = new StreamWriter(entryStream, Encoding.UTF8);
-
-            foreach (var kvp in subPrograms.OrderBy(k => k.Key))
             {
                 writer.WriteLine($":{kvp.Key}");
-                writer.WriteLine(kvp.Value.Mode == Mode.Absolute ? "G90" : "G91");
+                WriteProgram(writer, kvp.Value);
-
-                foreach (var code in kvp.Value.Codes)
-                    writer.WriteLine(GetCodeString(code));
-
                 writer.WriteLine("M99");
             }
+            return writer.ToString();
         }
 
         private void WriteEntities(ZipArchive zipArchive)
@@ -391,11 +422,16 @@ namespace OpenNest.IO
             }
         }
 
-        private void WriteDrawing(Stream stream, Drawing drawing)
+        /// <summary>Serializes a program in its current local frame, without transforming it.</summary>
+        public static string GetProgramText(Program program)
+        {
+            using var writer = new StringWriter(CultureInfo.InvariantCulture) { NewLine = "\n" };
+            WriteProgram(writer, program);
+            return writer.ToString();
+        }
+
+        private static void WriteProgram(TextWriter writer, Program program)
         {
-            var program = drawing.Program;
-            var writer = new StreamWriter(stream);
-            writer.AutoFlush = true;
 
             // Emit variable definitions before G-code
             foreach (var v in program.Variables.Values)
@@ -410,16 +446,11 @@ namespace OpenNest.IO
 
             writer.WriteLine(program.Mode == Mode.Absolute ? "G90" : "G91");
 
-            for (var i = 0; i < drawing.Program.Length; ++i)
+            foreach (var code in program.Codes)
-            {
-                var code = drawing.Program[i];
                 writer.WriteLine(GetCodeString(code));
         }
 
-            stream.Position = 0;
+        private static string FormatCoord(
-        }
-
-        private string FormatCoord(
             double value,
             string axis,
             Dictionary<string, string> variableRefs
@@ -430,7 +461,7 @@ namespace OpenNest.IO
             return System.Math.Round(value, OutputPrecision).ToString(CoordinateFormat);
         }
 
-        private string GetCodeString(ICode code)
+        private static string GetCodeString(ICode code)
         {
             switch (code.Type)
             {
@@ -534,7 +565,7 @@ namespace OpenNest.IO
             return string.Empty;
         }
 
-        private string GetLayerString(LayerType layer)
+        private static string GetLayerString(LayerType layer)
         {
             switch (layer)
             {

OpenNest.Mcp/Program.cs

@@ -1,16 +1,23 @@
+using System;
+using System.IO;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using OpenNest.Engine.Jobs;
 using OpenNest.Mcp;
 
+NestingEngineRegistry.LoadPlugins(Path.Combine(AppContext.BaseDirectory, "Engines"));
 var builder = Host.CreateApplicationBuilder(args);
 
 // stdout carries the JSON-RPC stream; console logs must go to stderr or they corrupt it.
 builder.Logging.AddConsole(o => o.LogToStandardErrorThreshold = LogLevel.Trace);
 
+using var toolGate = new SessionToolGate();
 builder.Services.AddSingleton<NestSession>();
 builder
     .Services.AddMcpServer()
+    .WithRequestFilters(filters => filters.AddCallToolFilter(
+        next => (context, token) => toolGate.RunAsync(ct => next(context, ct), token)))
     .WithStdioServerTransport()
     .WithToolsFromAssembly(typeof(Program).Assembly);
 

OpenNest.Mcp/SessionToolGate.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace OpenNest.Mcp;
+
+/// <summary>Serializes tool operations sharing a mutable nesting session.</summary>
+public sealed class SessionToolGate : IDisposable
+{
+    private readonly SemaphoreSlim gate = new(1, 1);
+
+    public async ValueTask<T> RunAsync<T>(Func<CancellationToken, ValueTask<T>> action, CancellationToken token)
+    {
+        await gate.WaitAsync(token).ConfigureAwait(false);
+        try
+        {
+            return await action(token).ConfigureAwait(false);
+        }
+        finally
+        {
+            gate.Release();
+        }
+    }
+
+    public void Dispose() => gate.Dispose();
+}

OpenNest.Mcp/Tools/NestingTools.cs

@@ -5,12 +5,11 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using ModelContextProtocol.Server;
+using OpenNest.Engine;
 using OpenNest.Engine.Fill;
 using OpenNest.Engine.Jobs;
-using OpenNest.Engine.Jobs.Adapters;
 using OpenNest.Engine.Jobs.Placement;
 using OpenNest.Geometry;
-using OpenNest.Engine;
 
 namespace OpenNest.Mcp.Tools
 {
@@ -251,91 +250,75 @@ namespace OpenNest.Mcp.Tools
         }
 
         [McpServerTool(Name = "autonest_plate")]
-        [Description(
+        [Description("Validated whole-job nesting onto an empty single sheet. Invalid results are discarded unless allow_invalid is explicitly true; unrepresentable or multiple-sheet results are always rejected.")]
-            "Mixed-part autonesting. Solves the drawings as one whole job against the plate using the named jobs engine and commits the resulting placements onto the plate."
-        )]
         public string AutoNestPlate(
-            [Description("Index of the plate")] int plateIndex,
+            [Description("Index of the empty plate")] int plateIndex,
             [Description("Comma-separated drawing names")] string drawingNames,
-            [Description("Comma-separated quantities for each drawing")] string quantities,
+            [Description("Comma-separated positive quantities")] string quantities,
-            [Description("Jobs engine name (Default, Strip, Vertical Remnant, Horizontal Remnant, StockLadder)")]
+            [Description("Registered jobs engine name, including loaded plug-ins")] string engine = null,
-                string engine = null
+            [Description("Explicitly keep representable layouts despite validation violations")] bool allow_invalid = false,
+            CancellationToken cancellationToken = default
         )
         {
             var plate = _session.GetPlate(plateIndex);
             if (plate == null)
                 return $"Error: plate {plateIndex} not found";
-
+            if (plate.Parts.Count > 0)
+                return "Error: autonest cannot use an occupied plate. Use fill_area or fill_remnants for existing obstacles.";
             if (string.IsNullOrWhiteSpace(drawingNames))
                 return "Error: drawingNames is required";
-
             if (string.IsNullOrWhiteSpace(quantities))
                 return "Error: quantities is required";
 
-            var engineName = string.IsNullOrWhiteSpace(engine)
+            var engineName = string.IsNullOrWhiteSpace(engine) ? _session.DefaultEngineName : engine.Trim();
-                ? _session.DefaultEngineName
-                : engine.Trim();
-
             var parsed = ParseItems(drawingNames, quantities);
             if (parsed.error != null)
                 return parsed.error;
-
             if (parsed.items.Any(item => item.Quantity <= 0))
                 return "Error: autonest quantities must be positive";
 
-            INestingEngine nestingEngine;
+            NestPipelineResult result;
             try
             {
-                nestingEngine = NestingEngineRegistry.Create(engineName);
+                result = NestPipeline.Run(new NestPipelineRequest(
+                    engineName, parsed.items, NestStockBuilder.SinglePlate(plate)), token: cancellationToken);
             }
             catch (NotSupportedException)
             {
                 return UnknownEngineMessage(engineName);
             }
 
-            var jobParts = new List<NestJobPart>(parsed.items.Count);
-            var drawingsByPartId = new Dictionary<string, Drawing>(StringComparer.Ordinal);
-            for (var i = 0; i < parsed.items.Count; i++)
-            {
-                var partId = $"part-{i}";
-                jobParts.Add(DrawingJobMapper.FromItem(partId, parsed.items[i]));
-                drawingsByPartId[partId] = parsed.items[i].Drawing;
-            }
-
-            // One physical sheet: this plate, this solve — the runner owns stock accounting.
-            var stock = DrawingJobMapper.FromPlate("plate-0", plate, 1);
-            var job = new NestJob(jobParts, [stock]);
-
-            var result = nestingEngine.Solve(job, null, CancellationToken.None);
-
-            var totalPlaced = 0;
-            foreach (var plateResult in result.Plates)
-            {
-                foreach (var pose in plateResult.Placements)
-                {
-                    if (!drawingsByPartId.TryGetValue(pose.PartId, out var drawing))
-                        continue;
-                    var part = new Part(drawing);
-                    part.Rotate(pose.Rotation);
-                    part.Location = new Vector(pose.X, pose.Y);
-                    part.UpdateBounds();
-                    plate.Parts.Add(part);
-                    totalPlaced++;
-                }
-            }
-
             var sb = new StringBuilder();
-            sb.AppendLine(
+            foreach (var violation in result.Violations)
-                $"AutoNest plate {plateIndex} ({engineName} engine): {(totalPlaced > 0 ? "success" : "no parts placed")}"
+                sb.AppendLine($"Violation: {violation}");
-            );
+            if (!result.CanKeep || result.Plates.Count > 1 || (!result.IsValid && !allow_invalid))
+            {
+                sb.AppendLine(result.Plates.Count > 1
+                    ? "Error: multiple result sheets cannot be merged onto one target, even with allow_invalid. Nothing committed."
+                    : !result.CanKeep
+                        ? "Error: result cannot be represented faithfully, even with allow_invalid. Nothing committed."
+                        : "Error: invalid result discarded. Set allow_invalid to explicitly keep its violations. Nothing committed.");
+                return sb.ToString();
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+            var proposed = result.Plates.SingleOrDefault();
+            var totalPlaced = proposed?.Parts.Count ?? 0;
+            if (totalPlaced > 0)
+            {
+                plate.Size = proposed.Stock.Size;
+                plate.PartSpacing = proposed.Stock.PartSpacing;
+                plate.EdgeSpacing = proposed.Stock.EdgeSpacing;
+                plate.Quadrant = proposed.Stock.Quadrant;
+                plate.Quantity = 1;
+                plate.Parts.AddRange(proposed.Parts);
+            }
+            sb.AppendLine($"AutoNest plate {plateIndex} ({engineName} engine): {(totalPlaced > 0 ? "success" : "no parts placed")}");
             sb.AppendLine($"  Parts placed: {totalPlaced}");
             sb.AppendLine($"  Total parts: {plate.Parts.Count}");
             sb.AppendLine($"  Utilization: {plate.Utilization():P1}");
-
+            foreach (var group in plate.Parts.GroupBy(p => p.BaseDrawing.Name))
-            var groups = plate.Parts.GroupBy(p => p.BaseDrawing.Name);
-            foreach (var group in groups)
                 sb.AppendLine($"  {group.Key}: {group.Count()}");
-
             return sb.ToString();
         }
 

OpenNest.Reporting/AtomicReportFile.cs

@@ -0,0 +1,27 @@
+namespace OpenNest.Reporting;
+
+internal static class AtomicReportFile
+{
+    internal static void Write(string destination, Action<Stream> render)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(destination);
+        ArgumentNullException.ThrowIfNull(render);
+        var target = Path.GetFullPath(destination);
+        var temporary = Path.Combine(Path.GetDirectoryName(target)!,
+            "." + Path.GetFileName(target) + "." + Guid.NewGuid().ToString("N") + ".tmp");
+        try
+        {
+            using (var stream = new FileStream(temporary, FileMode.CreateNew, FileAccess.Write, FileShare.None))
+            {
+                render(stream);
+                stream.Flush(flushToDisk: true);
+            }
+            // The sibling stays on the same filesystem. Never truncate/delete the target first.
+            File.Move(temporary, target, overwrite: true);
+        }
+        finally
+        {
+            File.Delete(temporary);
+        }
+    }
+}

OpenNest.Reporting/Fonts/LICENSE.txt

@@ -0,0 +1,48 @@
+DejaVu Sans 2.37 (regular and bold)
+Source: https://dejavu-fonts.github.io/
+Distributed unmodified from Ubuntu fonts-dejavu-core 2.37-8.
+
+Copyright: Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. 
+ Bitstream Vera is a trademark of Bitstream, Inc.
+ DejaVu changes are in public domain.
+License: bitstream-vera
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of the fonts accompanying this license ("Fonts") and associated
+ documentation files (the "Font Software"), to reproduce and distribute the
+ Font Software, including without limitation the rights to use, copy, merge,
+ publish, distribute, and/or sell copies of the Font Software, and to permit
+ persons to whom the Font Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright and trademark notices and this permission notice shall
+ be included in all copies of one or more of the Font Software typefaces.
+
+ The Font Software may be modified, altered, or added to, and in particular
+ the designs of glyphs or characters in the Fonts may be modified and
+ additional glyphs or characters may be added to the Fonts, only if the fonts
+ are renamed to names not containing either the words "Bitstream" or the word
+ "Vera".
+
+ This License becomes null and void to the extent applicable to Fonts or Font
+ Software that has been modified and is distributed under the "Bitstream
+ Vera" names.
+
+ The Font Software may be sold as part of a larger software package but no
+ copy of one or more of the Font Software typefaces may be sold by itself.
+
+ THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+ TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME
+ FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING
+ ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE
+ FONT SOFTWARE.
+
+ Except as contained in this notice, the names of Gnome, the Gnome
+ Foundation, and Bitstream Inc., shall not be used in advertising or
+ otherwise to promote the sale, use or other dealings in this Font Software
+ without prior written authorization from the Gnome Foundation or Bitstream
+ Inc., respectively. For further information, contact: fonts at gnome dot
+ org.

OpenNest.Reporting/NestPdfWriter.cs

@@ -0,0 +1,540 @@
+using System.Globalization;
+using MigraDoc.DocumentObjectModel;
+using MigraDoc.DocumentObjectModel.Tables;
+using MigraDoc.Rendering;
+using PdfSharp.Drawing;
+using PdfSharp.Pdf;
+
+namespace OpenNest.Reporting;
+
+/// <summary>
+/// Renders a detached <see cref="NestReportSnapshot"/> to PDF: MigraDoc owns text, tables and
+/// pagination; PDFsharp draws vector thumbnails and sheet diagrams into reserved layout areas.
+/// </summary>
+public static class NestPdfWriter
+{
+    private const double Margin = 36;
+    private const double BottomMargin = 50;
+    private const double HeaderDistance = 18;
+    private const double HeaderFontSize = 7.5;
+    private const int MaxHeaderLines = 3;
+    private const double BodyFontSize = 9;
+    private const double CellPadding = 3;
+    private const double ThumbnailWidth = 54;
+    private const double ThumbnailHeight = 36;
+    private const double PortraitWidth = 540;
+    private const double LandscapeWidth = 720;
+    private const double OverviewHeight = 320;
+    private const double DetailHeight = 400;
+
+    private static readonly XColor Fill = XColor.FromArgb(222, 222, 222);
+    private static readonly CultureInfo Invariant = CultureInfo.InvariantCulture;
+
+    // PDFsharp/MigraDoc layout and font state is process-wide and not safe for concurrent
+    // documents: parallel exports laid out text differently. Reports are rare, so serialize them.
+    private static readonly object RenderLock = new();
+
+    /// <summary>Thread-safe; concurrent calls are serialized.</summary>
+    public static void Write(NestReportSnapshot snapshot, string destination) =>
+        Write(snapshot, destination, null);
+
+    /// <param name="wrapOutput">Test seam for injecting late write failures.</param>
+    internal static void Write(NestReportSnapshot snapshot, string destination, Func<Stream, Stream>? wrapOutput)
+    {
+        ArgumentNullException.ThrowIfNull(snapshot);
+        ArgumentException.ThrowIfNullOrWhiteSpace(destination);
+        lock (RenderLock)
+            WriteSerialized(snapshot, destination, wrapOutput);
+    }
+
+    private static void WriteSerialized(NestReportSnapshot snapshot, string destination, Func<Stream, Stream>? wrapOutput)
+    {
+        ValidateText(snapshot);
+        ReportFonts.Initialize();
+
+        // Plan every diagram before layout; nothing below touches the destination until Save.
+        var plans = snapshot.Plates.Select(plate =>
+            NestReportDiagram.Plan(plate, LandscapeWidth, OverviewHeight, DetailHeight)).ToList();
+
+        var document = new Document();
+        document.Info.Title = snapshot.Name;
+        var normal = document.Styles[StyleNames.Normal]
+            ?? throw new InvalidOperationException("MigraDoc normal style is unavailable.");
+        normal.Font.Name = ReportFonts.Family;
+        normal.Font.Size = BodyFontSize;
+        var areas = new List<(Table Table, Action<XGraphics, XRect> Draw)>();
+        AddSummary(document, snapshot);
+        for (var index = 0; index < snapshot.Plates.Length; index++)
+            AddPlate(document, snapshot, snapshot.Plates[index], plans[index], areas);
+
+        var renderer = new PdfDocumentRenderer { Document = document };
+        renderer.RenderDocument();
+        using var pdf = renderer.PdfDocument;
+        // PDFsharp 6.2.4 disallows reading the page count after Save.
+        var pageCount = pdf.PageCount;
+        foreach (var (page, area, draw) in LocateAreas(renderer, pageCount, areas))
+        {
+            using var gfx = XGraphics.FromPdfPage(pdf.Pages[page - 1]);
+            var state = gfx.Save();
+            gfx.TranslateTransform(area.X, area.Y);
+            gfx.IntersectClip(new XRect(0, 0, area.Width, area.Height));
+            draw(gfx, area);
+            gfx.Restore(state);
+        }
+
+        pdf.Info.Title = snapshot.Name;
+        pdf.Info.Creator = "OpenNest";
+        pdf.Info.CreationDate = snapshot.GeneratedAt.UtcDateTime;
+        AtomicReportFile.Write(destination, stream => pdf.Save(wrapOutput?.Invoke(stream) ?? stream, false));
+    }
+
+    private static void ValidateText(NestReportSnapshot snapshot)
+    {
+        ReportFonts.ValidateText(snapshot.Name, "Nest name");
+        ReportFonts.ValidateText(snapshot.Customer, "Customer");
+        ReportFonts.ValidateText(snapshot.Notes, "Notes");
+        ReportFonts.ValidateText(snapshot.Material, "Material");
+        ReportFonts.ValidateText(snapshot.Grade, "Material grade");
+        foreach (var drawing in snapshot.Drawings)
+            ReportFonts.ValidateText(drawing.Name, $"Drawing {drawing.Id} name");
+    }
+
+    private static void AddSummary(Document document, NestReportSnapshot snapshot)
+    {
+        var section = AddSection(document, Orientation.Portrait, PortraitWidth, $"Nest report: {snapshot.Name}");
+        var title = section.AddParagraph("Nest Report");
+        title.Format.Font.Size = 14;
+        title.Format.Font.Bold = true;
+        title.Format.SpaceAfter = Unit.FromPoint(6);
+
+        var info = AddTable(section, 130, 410);
+        info.Borders.Visible = false;
+        AddInfoRow(info, "Nest:", snapshot.Name);
+        if (snapshot.Customer.Length > 0)
+            AddInfoRow(info, "Customer:", snapshot.Customer);
+        AddInfoRow(info, "Material:", Material(snapshot));
+        AddInfoRow(info, "Thickness:", Thickness(snapshot));
+        AddInfoRow(info, "Units:", snapshot.Units == "mm" ? "millimeters (mm)" : "inches (in)");
+        AddInfoRow(info, "Generated:", snapshot.GeneratedAt.ToString("yyyy-MM-dd HH:mm zzz", Invariant));
+        AddInfoRow(info, "Distinct layouts:", snapshot.Plates.Length.ToString(Invariant));
+        AddInfoRow(info, "Total physical sheets:", snapshot.TotalSheets.ToString(Invariant));
+        if (snapshot.Notes.Length > 0)
+        {
+            // Free paragraphs split across pages; a table row taller than a page would be clipped.
+            AddHeading(section, "Notes");
+            AddLines(section.AddParagraph(), ReportText.Wrap(snapshot.Notes, BodyFont(false), PortraitWidth));
+        }
+
+        AddHeading(section, "Plates");
+        if (snapshot.Plates.Length == 0)
+            section.AddParagraph("No plates in this job.");
+        else
+        {
+            var plates = AddTable(section, 60, 200, 80, 100, 100);
+            AddHeader(plates, "Plate", "Stock size", "Copies", "Parts/sheet", "Utilization");
+            foreach (var plate in snapshot.Plates)
+                AddRow(plates, $"Plate {plate.Number}", false, plate.Number.ToString(Invariant), SheetSize(snapshot, plate),
+                    plate.Copies.ToString(Invariant), plate.Parts.Length.ToString(Invariant), Percent(plate.Utilization));
+        }
+
+        AddHeading(section, "Parts");
+        if (snapshot.Drawings.Length == 0)
+        {
+            section.AddParagraph("No parts in this job.");
+            return;
+        }
+        // Column widths fit the bold headings on one line (measured, plus padding).
+        var parts = AddTable(section, 36, 62, 138, 56, 50, 56, 42, 100);
+        AddHeader(parts, "ID", "Part", "Drawing", "Required", "Nested", "Shortage", "Extra", "Plates");
+        foreach (var drawing in snapshot.Drawings)
+        {
+            var row = AddRow(parts, $"Drawing {drawing.Id}", false, drawing.Id, null, drawing.Name,
+                drawing.Required.ToString(Invariant), drawing.Nested.ToString(Invariant),
+                drawing.Shortage.ToString(Invariant), drawing.Extra.ToString(Invariant), ReportText.Ranges(drawing.Plates));
+            var image = row.Cells[1].AddParagraph().AddImage(Thumbnail(drawing.Geometry));
+            image.Width = Unit.FromPoint(ThumbnailWidth);
+            image.Height = Unit.FromPoint(ThumbnailHeight);
+        }
+    }
+
+    private static void AddPlate(Document document, NestReportSnapshot snapshot, ReportPlate plate,
+        PlateDiagramPlan plan, List<(Table, Action<XGraphics, XRect>)> areas)
+    {
+        var heading = $"Plate {plate.Number} of {snapshot.Plates.Length}";
+        var header = new List<string> { $"Nest report: {snapshot.Name}", heading, SheetSize(snapshot, plate) };
+        // Unset material/thickness are stated in the page body, not repeated in every header.
+        if (snapshot.Material.Length + snapshot.Grade.Length > 0)
+            header.Add(Material(snapshot));
+        if (snapshot.Thickness > 0)
+            header.Add(Thickness(snapshot));
+        var section = AddSection(document, Orientation.Landscape, LandscapeWidth, string.Join("  |  ", header));
+        var title = section.AddParagraph(heading);
+        title.Format.Font.Size = 13;
+        title.Format.Font.Bold = true;
+
+        var info = AddTable(section, 80, 280, 90, 270);
+        info.Borders.Visible = false;
+        AddInfoRow(info, "Nest:", snapshot.Name, "Sheet size:", SheetSize(snapshot, plate));
+        AddInfoRow(info, "Material:", Material(snapshot), "Copies:", plate.Copies.ToString(Invariant));
+        AddInfoRow(info, "Thickness:", Thickness(snapshot), "Part spacing:",
+            $"{Number(plate.PartSpacing)} {snapshot.Units}");
+        AddInfoRow(info, "Parts/sheet:", plate.Parts.Length.ToString(Invariant), "Utilization:",
+            Percent(plate.Utilization) + " (net part area / full sheet)");
+
+        var overview = AddReservedArea(section, null, plan.Overview.Size.Height);
+        areas.Add((overview, (gfx, _) => DrawView(gfx, plate, plan.Overview)));
+
+        var legend = section.AddParagraph("Filled outlines are closed parts; open material paths such as tab gaps are shown without fill. Dashed lines are scrap cutoffs.");
+        legend.Format.Font.Size = 7.5;
+        legend.Format.SpaceBefore = Unit.FromPoint(4);
+        if (plan.Overview.Grid is { } grid)
+        {
+            var names = string.Join(", ", plan.Details.Select(detail => detail.Cell));
+            var fallback = section.AddParagraph();
+            fallback.Format.Font.Size = 7.5;
+            AddLines(fallback, ReportText.Wrap(
+                $"Some part IDs are too small to label at this scale. Grid rows are lettered from the top and columns numbered from the left; cells outlined dash-dot have detail views on the following pages: {names}.",
+                new XFont(ReportFonts.Family, 7.5), LandscapeWidth));
+        }
+        var approval = section.AddParagraph("This report is not a geometry or CNC approval.");
+        approval.Format.Font.Size = 7.5;
+        approval.Format.SpaceAfter = Unit.FromPoint(4);
+
+        var names2 = snapshot.Drawings.ToDictionary(drawing => drawing.Id, drawing => drawing.Name, StringComparer.Ordinal);
+        var perSheet = plate.Parts.GroupBy(part => part.ReportId, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => (long)group.Count(), StringComparer.Ordinal);
+        var parts = AddTable(section, 60, 400, 110, 150);
+        AddHeader(parts, "ID", "Drawing", "Qty/sheet", $"Total ({plate.Copies} copies)");
+        foreach (var drawing in snapshot.Drawings.Where(drawing => perSheet.ContainsKey(drawing.Id)))
+        {
+            var count = perSheet[drawing.Id];
+            AddRow(parts, $"Plate {plate.Number}, drawing {drawing.Id}", false, drawing.Id, names2[drawing.Id],
+                count.ToString(Invariant), checked(count * plate.Copies).ToString(Invariant));
+        }
+
+        foreach (var detail in plan.Details)
+        {
+            var bounds = detail.CellBounds!;
+            var caption = $"Plate {plate.Number} detail {detail.Cell}: X {Number(bounds.Left)} to {Number(bounds.Right)}, Y {Number(bounds.Bottom)} to {Number(bounds.Top)} {snapshot.Units}. Parts centered in the dash-dot cell are labeled.";
+            var table = AddReservedArea(section, caption, detail.Size.Height);
+            areas.Add((table, (gfx, _) => DrawView(gfx, plate, detail)));
+        }
+    }
+
+    /// <summary>A fixed-height, never-split table row reserves a vector drawing area in MigraDoc's flow.</summary>
+    private static Table AddReservedArea(Section section, string? caption, double height)
+    {
+        var table = AddTable(section, LandscapeWidth);
+        table.Borders.Visible = false;
+        table.LeftPadding = table.RightPadding = Unit.Zero;
+        table.TopPadding = table.BottomPadding = Unit.Zero;
+        table.Format.SpaceBefore = Unit.FromPoint(4);
+        if (caption != null)
+        {
+            var row = AddRow(table, "Detail caption", true, caption);
+            row.KeepWith = 1;
+        }
+        var reserved = table.AddRow();
+        reserved.HeightRule = RowHeightRule.Exactly;
+        reserved.Height = Unit.FromPoint(height);
+        return table;
+    }
+
+    private static IEnumerable<(int Page, XRect Area, Action<XGraphics, XRect> Draw)> LocateAreas(
+        PdfDocumentRenderer renderer, int pageCount, List<(Table Table, Action<XGraphics, XRect> Draw)> areas)
+    {
+        var found = new (int Page, XRect Area)?[areas.Count];
+        for (var page = 1; page <= pageCount; page++)
+        {
+            var renderInfos = renderer.DocumentRenderer?.GetRenderInfoFromPage(page)
+                ?? throw new InvalidOperationException("MigraDoc render information is unavailable.");
+            foreach (var info in renderInfos)
+            {
+                var index = areas.FindIndex(area => ReferenceEquals(area.Table, info.DocumentObject));
+                if (index < 0)
+                    continue;
+                var table = areas[index].Table;
+                // Only the page holding the reserved (last) row receives the drawing.
+                if (info.FormatInfo is not TableFormatInfo format || format.EndRow != table.Rows.Count - 1)
+                    continue;
+                if (found[index] != null)
+                    throw new InvalidOperationException($"Report drawing area {index + 1} was laid out twice.");
+                var content = info.LayoutInfo.ContentArea;
+                var height = table.Rows[table.Rows.Count - 1].Height.Point;
+                found[index] = (page, new XRect(content.X.Point, content.Y.Point + content.Height.Point - height,
+                    content.Width.Point, height));
+            }
+        }
+        for (var index = 0; index < areas.Count; index++)
+        {
+            var (page, area) = found[index]
+                ?? throw new InvalidOperationException($"Report drawing area {index + 1} was not laid out.");
+            yield return (page, area, areas[index].Draw);
+        }
+    }
+
+    private static void DrawView(XGraphics gfx, ReportPlate plate, DiagramView view)
+    {
+        var fit = view.Fit;
+        // Detail views clip exactly at their frame line so cropped neighbours stop there.
+        var frame = new XRect(0.5, 0.5, view.Size.Width - 1, view.Size.Height - 1);
+        var state = gfx.Save();
+        if (view.CellBounds != null)
+            gfx.IntersectClip(frame);
+        // The map grid lies beneath the sheet and parts so it never hides an outline.
+        if (view.Grid is { } grid)
+            DrawGrid(gfx, grid, fit);
+        gfx.DrawRectangle(new XPen(XColors.Black, 1), fit.Rect(plate.Bounds));
+        var outline = new XPen(XColors.Black, 0.6);
+        foreach (var part in plate.Parts)
+            DrawGeometry(gfx, part.Geometry, fit, outline);
+        // PDFsharp multiplies dash patterns by the pen width; the preset styles are so short at
+        // these thin widths that they print as solid lines.
+        var cutoff = new XPen(XColors.Black, 0.75) { DashPattern = [9, 3] };
+        foreach (var geometry in plate.Cutoffs)
+            StrokeContours(gfx, geometry, fit, cutoff);
+        // Long dash-dot, so detail cells are never confused with dashed scrap cutoffs.
+        var detail = new XPen(XColors.Black, 1.6) { DashPattern = [9, 3, 1, 3] };
+        if (view.Grid is { } overviewGrid)
+        {
+            foreach (var (row, column) in overviewGrid.DetailCells)
+                gfx.DrawRectangle(detail, fit.Rect(overviewGrid.Cell(row, column)));
+        }
+        if (view.CellBounds is { } cell)
+            gfx.DrawRectangle(detail, fit.Rect(cell));
+        var font = NestReportDiagram.LabelFont();
+        foreach (var label in view.Labels)
+        {
+            gfx.DrawRectangle(XBrushes.White, label.Box);
+            gfx.DrawString(label.Id, font, XBrushes.Black, label.Box, XStringFormats.Center);
+        }
+        gfx.Restore(state);
+        // Frame the viewport so cropped neighbouring parts read as intentional.
+        if (view.CellBounds != null)
+            gfx.DrawRectangle(new XPen(XColors.Gray, 0.75), frame);
+    }
+
+    private static void DrawGrid(XGraphics gfx, DiagramGrid grid, Fit fit)
+    {
+        var line = new XPen(XColors.Gray, 0.3) { DashPattern = [3, 6] };
+        var area = fit.Rect(grid.Union);
+        for (var column = 0; column <= grid.Columns; column++)
+        {
+            var x = area.X + column * grid.CellLength * fit.Scale;
+            gfx.DrawLine(line, x, area.Y, x, area.Y + grid.Rows * grid.CellWidth * fit.Scale);
+        }
+        for (var row = 0; row <= grid.Rows; row++)
+        {
+            var y = area.Y + row * grid.CellWidth * fit.Scale;
+            gfx.DrawLine(line, area.X, y, area.X + grid.Columns * grid.CellLength * fit.Scale, y);
+        }
+        var font = NestReportDiagram.LabelFont();
+        for (var column = 0; column < grid.Columns; column++)
+        {
+            var x = area.X + (column + 0.5) * grid.CellLength * fit.Scale;
+            gfx.DrawString((column + 1).ToString(Invariant), font, XBrushes.Black,
+                new XRect(x - 20, area.Y - 11, 40, 10), XStringFormats.BottomCenter);
+        }
+        for (var row = 0; row < grid.Rows; row++)
+        {
+            var y = area.Y + (row + 0.5) * grid.CellWidth * fit.Scale;
+            gfx.DrawString(ReportText.RowName(row), font, XBrushes.Black,
+                new XRect(area.X - 16, y - 5, 14, 10), XStringFormats.CenterRight);
+        }
+    }
+
+    private static string Thumbnail(ReportGeometry geometry)
+    {
+        using var document = new PdfDocument();
+        var page = document.AddPage();
+        page.Width = XUnit.FromPoint(ThumbnailWidth);
+        page.Height = XUnit.FromPoint(ThumbnailHeight);
+        using (var gfx = XGraphics.FromPdfPage(page))
+        {
+            var fit = Fit.Create(geometry.Bounds, new XRect(2, 2, ThumbnailWidth - 4, ThumbnailHeight - 4));
+            DrawGeometry(gfx, geometry, fit, new XPen(XColors.Black, 0.5));
+        }
+        using var stream = new MemoryStream();
+        document.Save(stream, false);
+        // MigraDoc embeds a PDF image source as a vector form XObject, not a raster image.
+        return "base64:" + Convert.ToBase64String(stream.ToArray());
+    }
+
+    private static void DrawGeometry(XGraphics gfx, ReportGeometry geometry, Fit fit, XPen pen)
+    {
+        if (geometry.StrokeOnly)
+        {
+            StrokeContours(gfx, geometry, fit, pen);
+            return;
+        }
+        // Every contour is closed here, so CloseFigure separates the subpaths.
+        var path = new XGraphicsPath();
+        foreach (var contour in geometry.Contours)
+        {
+            AddContour(path, contour, fit);
+            path.CloseFigure();
+        }
+        path.FillMode = XFillMode.Alternate; // Even-odd: holes stay unfilled.
+        gfx.DrawPath(pen, new XSolidBrush(Fill), path);
+    }
+
+    /// <summary>
+    /// PDFsharp's StartFigure does not emit a move-to after an open figure, which would draw a
+    /// false segment across a tab gap to the next contour. Stroke each contour as its own path.
+    /// </summary>
+    private static void StrokeContours(XGraphics gfx, ReportGeometry geometry, Fit fit, XPen pen)
+    {
+        foreach (var contour in geometry.Contours)
+        {
+            var path = new XGraphicsPath();
+            AddContour(path, contour, fit);
+            if (contour.Closed)
+                path.CloseFigure();
+            gfx.DrawPath(pen, path);
+        }
+    }
+
+    private static void AddContour(XGraphicsPath path, ReportContour contour, Fit fit)
+    {
+        foreach (var segment in contour.Segments)
+        {
+            if (segment.Center == null)
+            {
+                path.AddLine(fit.Point(segment.Start), fit.Point(segment.End));
+                continue;
+            }
+            var center = fit.Point(segment.Center);
+            var radius = segment.Radius * fit.Scale;
+            var box = new XRect(center.X - radius, center.Y - radius, 2 * radius, 2 * radius);
+            // Page Y points down, so model angles and sweeps change sign.
+            path.AddArc(box, -Degrees(segment.StartAngle), -Degrees(segment.SweepAngle));
+        }
+    }
+
+    private static double Degrees(double radians) => radians * 180 / System.Math.PI;
+
+    private static XFont BodyFont(bool bold) =>
+        new(ReportFonts.Family, BodyFontSize, bold ? XFontStyleEx.Bold : XFontStyleEx.Regular);
+
+    private static Section AddSection(Document document, Orientation orientation, double width, string header)
+    {
+        var section = document.AddSection();
+        var setup = section.PageSetup;
+        setup.PageFormat = PageFormat.Letter;
+        setup.Orientation = orientation;
+        setup.LeftMargin = setup.RightMargin = Unit.FromPoint(Margin);
+        setup.BottomMargin = Unit.FromPoint(BottomMargin);
+        setup.FooterDistance = Unit.FromPoint(20);
+
+        // Every page, including continuations, identifies its job and plate. MigraDoc does not
+        // push the body below a tall header, so size the top margin from the wrapped header.
+        var headerFont = new XFont(ReportFonts.Family, HeaderFontSize);
+        var lines = ReportText.Wrap(header, headerFont, width);
+        if (lines.Count > MaxHeaderLines)
+            throw new NotSupportedException($"Page header (nest name): text needs {lines.Count} lines; this report supports at most {MaxHeaderLines}.");
+        setup.HeaderDistance = Unit.FromPoint(HeaderDistance);
+        setup.TopMargin = Unit.FromPoint(HeaderDistance + lines.Count * headerFont.GetHeight() + 8);
+        var top = section.Headers.Primary.AddParagraph();
+        top.Format.Font.Size = HeaderFontSize;
+        top.Format.Font.Color = Colors.DimGray;
+        AddLines(top, lines);
+
+        var footer = section.Footers.Primary.AddParagraph("Page ");
+        footer.AddPageField();
+        footer.AddText(" of ");
+        footer.AddNumPagesField();
+        footer.AddText("  |  Diagram fitted to page; not a dimensioned cutting drawing.");
+        footer.Format.Font.Size = 7.5;
+        return section;
+    }
+
+    private static void AddHeading(Section section, string text)
+    {
+        var heading = section.AddParagraph(text);
+        heading.Format.Font.Bold = true;
+        heading.Format.Font.Size = 11;
+        heading.Format.SpaceBefore = Unit.FromPoint(10);
+        heading.Format.SpaceAfter = Unit.FromPoint(4);
+        heading.Format.KeepWithNext = true;
+    }
+
+    private static Table AddTable(Section section, params double[] widths)
+    {
+        var table = section.AddTable();
+        table.Borders.Width = 0.5;
+        table.Borders.Color = Colors.Gray;
+        table.LeftPadding = table.RightPadding = Unit.FromPoint(CellPadding);
+        table.TopPadding = table.BottomPadding = Unit.FromPoint(1.5);
+        foreach (var width in widths)
+            table.AddColumn(Unit.FromPoint(width));
+        return table;
+    }
+
+    /// <summary>Heading rows repeat at the top of every continuation page.</summary>
+    private static void AddHeader(Table table, params string[] cells)
+    {
+        var row = AddRow(table, "Table heading", true, cells);
+        row.HeadingFormat = true;
+        row.Format.Font.Bold = true;
+        row.Shading.Color = Colors.LightGray;
+    }
+
+    private static void AddInfoRow(Table table, params string[] cells)
+    {
+        var row = table.AddRow();
+        row.VerticalAlignment = VerticalAlignment.Top;
+        for (var index = 0; index < cells.Length; index++)
+        {
+            var bold = index % 2 == 0;
+            FillCell(table, row, index, cells[index], bold, $"{cells[index - index % 2].TrimEnd(':')} field");
+            if (bold)
+                row.Cells[index].Format.Font.Bold = true;
+        }
+    }
+
+    /// <summary>Adds wrapped text cells; a null cell is left empty for non-text content.</summary>
+    private static Row AddRow(Table table, string context, bool bold, params string?[] cells)
+    {
+        var row = table.AddRow();
+        row.VerticalAlignment = VerticalAlignment.Center;
+        for (var index = 0; index < cells.Length; index++)
+        {
+            if (cells[index] != null)
+                FillCell(table, row, index, cells[index]!, bold, context);
+        }
+        return row;
+    }
+
+    private static void FillCell(Table table, Row row, int index, string text, bool bold, string context)
+    {
+        var width = table.Columns[index].Width.Point - table.LeftPadding.Point - table.RightPadding.Point;
+        AddLines(row.Cells[index].AddParagraph(), ReportText.Cell(text, BodyFont(bold), width, context));
+    }
+
+    private static void AddLines(Paragraph paragraph, IReadOnlyList<string> lines)
+    {
+        for (var line = 0; line < lines.Count; line++)
+        {
+            if (line > 0)
+                paragraph.AddLineBreak();
+            paragraph.AddText(lines[line]);
+        }
+    }
+
+    private static string Material(NestReportSnapshot snapshot)
+    {
+        var material = $"{snapshot.Material} {snapshot.Grade}".Trim();
+        return material.Length == 0 ? "Not specified" : material;
+    }
+
+    // Zero thickness means "unset" in a new nest; never present it as a genuine value.
+    private static string Thickness(NestReportSnapshot snapshot) =>
+        snapshot.Thickness > 0 ? $"{Number(snapshot.Thickness)} {snapshot.Units}" : "Not specified";
+
+    private static string SheetSize(NestReportSnapshot snapshot, ReportPlate plate) =>
+        $"{Number(plate.Bounds.Length)} x {Number(plate.Bounds.Width)} {snapshot.Units}";
+
+    private static string Number(double value) => value.ToString("0.####", Invariant);
+
+    private static string Percent(double value) => (value * 100).ToString("0.0", Invariant) + "%";
+}

OpenNest.Reporting/NestReportBuilder.cs

@@ -0,0 +1,131 @@
+using System.Collections.Immutable;
+using System.Globalization;
+using OpenNest.Geometry;
+
+namespace OpenNest.Reporting;
+
+public static class NestReportBuilder
+{
+    /// <summary>
+    /// Capture synchronously while the caller keeps the nest stable. No quantity refresh,
+    /// domain cloning, or event-wired temporary plates are used.
+    /// </summary>
+    public static NestReportSnapshot Capture(Nest nest, DateTimeOffset generatedAt)
+    {
+        ArgumentNullException.ThrowIfNull(nest);
+        var ordered = new List<DrawingCount>();
+        var byReference = new Dictionary<Drawing, DrawingCount>(ReferenceEqualityComparer.Instance);
+        var plates = ImmutableArray.CreateBuilder<ReportPlate>();
+
+        DrawingCount Register(Drawing drawing)
+        {
+            if (byReference.TryGetValue(drawing, out var existing))
+                return existing;
+            var item = new DrawingCount(drawing, "R" + (ordered.Count + 1).ToString("D3", CultureInfo.InvariantCulture));
+            byReference.Add(drawing, item);
+            ordered.Add(item);
+            return item;
+        }
+
+        for (var index = 0; index < nest.Plates.Count; index++)
+        {
+            var number = index + 1;
+            var plate = nest.Plates[index];
+            if (plate == null)
+                throw new InvalidOperationException($"Plate {number}: missing plate.");
+            if (!PositiveFinite(plate.Size.Length) || !PositiveFinite(plate.Size.Width)
+                || !PositiveFinite(plate.Area()))
+                throw new InvalidOperationException($"Plate {number}: sheet dimensions must be finite and positive.");
+            if (plate.Quantity <= 0)
+                throw new InvalidOperationException($"Plate {number}: copies must be a positive integer.");
+            if (!double.IsFinite(plate.PartSpacing) || plate.PartSpacing < 0)
+                throw new InvalidOperationException($"Plate {number}: part spacing must be finite and nonnegative.");
+
+            var box = plate.BoundingBox(false);
+            var bounds = new ReportBounds(box.Left, box.Bottom, box.Right, box.Top);
+            if (!double.IsFinite(bounds.Left) || !double.IsFinite(bounds.Bottom)
+                || !double.IsFinite(bounds.Right) || !double.IsFinite(bounds.Top))
+                throw new InvalidOperationException($"Plate {number}: sheet bounds are not finite.");
+            var parts = ImmutableArray.CreateBuilder<ReportPlacement>();
+            var cutoffs = ImmutableArray.CreateBuilder<ReportGeometry>();
+            var perSheet = new Dictionary<DrawingCount, long>();
+            var area = 0.0;
+            for (var partIndex = 0; partIndex < plate.Parts.Count; partIndex++)
+            {
+                var part = plate.Parts[partIndex];
+                var context = $"Plate {number}, part {partIndex + 1} ('{part?.BaseDrawing?.Name}')";
+                if (part?.BaseDrawing == null)
+                    throw new InvalidOperationException($"{context}: missing part or drawing reference.");
+                var geometry = NestReportGeometry.Capture(part.Program, part.Location, context);
+                if (part.BaseDrawing.IsCutOff)
+                {
+                    cutoffs.Add(geometry);
+                    continue;
+                }
+
+                var item = Register(part.BaseDrawing);
+                parts.Add(new ReportPlacement(item.Id, geometry));
+                perSheet.TryGetValue(item, out var count);
+                perSheet[item] = checked(count + 1);
+                var partArea = part.BaseDrawing.Area;
+                if (!double.IsFinite(partArea) || partArea < 0)
+                    throw new InvalidOperationException($"{context}: net part area is invalid.");
+                area += partArea;
+            }
+
+            foreach (var (item, count) in perSheet)
+            {
+                item.Nested = checked(item.Nested + checked(count * plate.Quantity));
+                item.Plates.Add(number);
+            }
+            var utilization = area / plate.Area();
+            if (!double.IsFinite(utilization))
+                throw new InvalidOperationException($"Plate {number}: utilization is not finite.");
+            plates.Add(new ReportPlate(number, bounds, plate.Quantity, plate.PartSpacing,
+                utilization, parts.ToImmutable(), cutoffs.ToImmutable()));
+        }
+
+        // OrderBy is stable, so the original enumeration breaks equal name/path ties.
+        foreach (var drawing in nest.Drawings
+            .Where(drawing => !drawing.IsCutOff)
+            .OrderBy(drawing => drawing.Name ?? "", StringComparer.Ordinal)
+            .ThenBy(drawing => drawing.Source?.Path ?? "", StringComparer.Ordinal))
+            Register(drawing);
+
+        var drawings = ImmutableArray.CreateBuilder<ReportDrawing>();
+        foreach (var item in ordered)
+        {
+            var drawing = item.Drawing;
+            var context = $"Drawing {item.Id} ('{drawing.Name}')";
+            var required = (long)drawing.Quantity.Required;
+            if (required < 0)
+                throw new InvalidOperationException($"{context}: required quantity cannot be negative.");
+            var geometry = NestReportGeometry.Capture(drawing.Program, new Vector(), context);
+            drawings.Add(new ReportDrawing(item.Id, drawing.Name ?? "", required, item.Nested,
+                System.Math.Max(checked(required - item.Nested), 0),
+                System.Math.Max(checked(item.Nested - required), 0), item.Plates.ToImmutableArray(), geometry));
+        }
+
+        var units = nest.Units switch
+        {
+            Units.Inches => "in",
+            Units.Millimeters => "mm",
+            _ => throw new InvalidOperationException("Nest: unsupported units."),
+        };
+        if (!double.IsFinite(nest.Thickness) || nest.Thickness < 0)
+            throw new InvalidOperationException("Nest: thickness must be finite and nonnegative.");
+        return new NestReportSnapshot(nest.Name ?? "", nest.Customer ?? "", nest.Notes ?? "",
+            nest.Material?.Name ?? "", nest.Material?.Grade ?? "", nest.Thickness, units, generatedAt,
+            drawings.ToImmutable(), plates.ToImmutable());
+    }
+
+    private static bool PositiveFinite(double value) => double.IsFinite(value) && value > 0;
+
+    private sealed class DrawingCount(Drawing drawing, string id)
+    {
+        public Drawing Drawing { get; } = drawing;
+        public string Id { get; } = id;
+        public long Nested { get; set; }
+        public List<int> Plates { get; } = [];
+    }
+}

OpenNest.Reporting/NestReportDiagram.cs

@@ -0,0 +1,333 @@
+using OpenNest.Geometry;
+using PdfSharp.Drawing;
+
+namespace OpenNest.Reporting;
+
+/// <summary>A part ID label in canvas-local page coordinates (Y down).</summary>
+internal sealed record DiagramLabel(int Part, string Id, XRect Box);
+
+/// <summary>Map grid over the overview; rows are lettered from the top, columns numbered from the left.</summary>
+internal sealed record DiagramGrid(ReportBounds Union, double CellLength, double CellWidth, int Columns, int Rows,
+    IReadOnlyList<(int Row, int Column)> DetailCells)
+{
+    public string Name(int row, int column) => ReportText.RowName(row) + (column + 1).ToString(System.Globalization.CultureInfo.InvariantCulture);
+
+    public ReportBounds Cell(int row, int column)
+    {
+        var left = Union.Left + column * CellLength;
+        var top = Union.Top - row * CellWidth;
+        return new ReportBounds(left, top - CellWidth, left + CellLength, top);
+    }
+}
+
+/// <summary>One drawn view of a plate: the fitted overview or a zoomed grid-cell detail.</summary>
+internal sealed record DiagramView(XSize Size, Fit Fit, IReadOnlyList<DiagramLabel> Labels,
+    DiagramGrid? Grid, string? Cell, ReportBounds? CellBounds);
+
+internal sealed record PlateDiagramPlan(DiagramView Overview, IReadOnlyList<DiagramView> Details);
+
+/// <summary>
+/// Plans labels before any PDF output. IDs are never shrunk below <see cref="LabelFontSize"/> or
+/// dropped: a label that cannot sit legibly inside its part's material at overview scale is placed
+/// in a zoomed map-grid detail view instead, or the report fails with the part identified.
+/// </summary>
+internal static class NestReportDiagram
+{
+    internal const double LabelFontSize = 7;
+    internal const int MaxDetailViews = 24;
+    private const double LabelPadding = 1;
+    // Minimum white space between a label and any edge, hole, cutoff or other label.
+    private const double Clearance = 1.5;
+    private const double Inset = 5;
+    private const double GutterLeft = 16;
+    private const double GutterTop = 12;
+    private const double DetailMargin = 0.08;
+    private static readonly double[] Zooms = [1, 2, 4];
+
+    internal static XFont LabelFont()
+    {
+        ReportFonts.Initialize();
+        return new(ReportFonts.Family, LabelFontSize, XFontStyleEx.Bold);
+    }
+
+    /// <summary>Chord tolerance for placement-only flattening, relative to the part size.</summary>
+    internal static double ChordTolerance(ReportBounds bounds) =>
+        System.Math.Max(System.Math.Max(bounds.Length, bounds.Width) * 0.0005, 1e-9);
+
+    /// <summary>PolyLabel search precision, relative to the part size.</summary>
+    internal static double PolePrecision(ReportBounds bounds) =>
+        System.Math.Max(System.Math.Max(bounds.Length, bounds.Width) * 0.005, 1e-9);
+
+    internal static PlateDiagramPlan Plan(ReportPlate plate, double width, double overviewHeight, double detailHeight)
+    {
+        var shapes = plate.Parts.Select(part => new Shape(part.Geometry)).ToList();
+        var obstacles = shapes.Concat(plate.Cutoffs.Select(cutoff => new Shape(cutoff))).ToList();
+        var union = Union(plate, obstacles);
+        var font = LabelFont();
+        var all = Enumerable.Range(0, plate.Parts.Length).ToList();
+        var canvas = new XSize(width, overviewHeight);
+        var overviewView = new XRect(0, 0, width, overviewHeight);
+
+        var fit = Fit.Create(union, new XRect(Inset, Inset, width - 2 * Inset, overviewHeight - 2 * Inset));
+        var labels = PlaceLabels(plate, shapes, obstacles, all, fit, overviewView, font, out var failed);
+        if (failed.Count == 0)
+            return new PlateDiagramPlan(new DiagramView(canvas, fit, labels, null, null, null), []);
+
+        // Reserve map-grid gutters, then re-place what still fits at overview scale.
+        fit = Fit.Create(union, new XRect(GutterLeft, GutterTop, width - GutterLeft - Inset, overviewHeight - GutterTop - Inset));
+        labels = PlaceLabels(plate, shapes, obstacles, all, fit, overviewView, font, out failed);
+        var failedSet = failed.ToHashSet();
+        var required = failed.Max(index => RequiredScale(plate, index, font));
+        var inner = new XRect(Inset, Inset, width - 2 * Inset, detailHeight - 2 * Inset);
+        var legibleGrid = false;
+        foreach (var zoom in Zooms)
+        {
+            var scale = required * zoom;
+            // Cells evenly divide the sheet (no overrun); each is at most the size a detail view
+            // shows at the required scale, so the zoom only increases.
+            var columns = System.Math.Max(1, (int)System.Math.Ceiling(union.Length * scale * (1 + 2 * DetailMargin) / inner.Width));
+            var rows = System.Math.Max(1, (int)System.Math.Ceiling(union.Width * scale * (1 + 2 * DetailMargin) / inner.Height));
+            var cellLength = union.Length / columns;
+            var cellWidth = union.Width / rows;
+            var grid = new DiagramGrid(union, cellLength, cellWidth, columns, rows, []);
+            // Every grid line and gutter name must stay readable on the overview.
+            if (!GridIsLegible(grid, fit, font))
+                continue;
+            legibleGrid = true;
+            (int Row, int Column) CellOf(int index) => CellIndex(plate, index, union, columns, rows);
+
+            var cells = failed.Select(CellOf).Distinct().OrderBy(cell => cell.Row).ThenBy(cell => cell.Column).ToList();
+            if (cells.Count > MaxDetailViews)
+                throw new NotSupportedException($"Plate {plate.Number}: legible part ID labels would need {cells.Count} detail views; this report supports at most {MaxDetailViews} per plate.");
+            grid = grid with { DetailCells = cells };
+            var details = new List<DiagramView>();
+            var unplaced = new List<int>();
+            foreach (var (row, column) in cells)
+            {
+                var cell = grid.Cell(row, column);
+                var marginX = cellLength * DetailMargin;
+                var marginY = cellWidth * DetailMargin;
+                var view = new ReportBounds(cell.Left - marginX, cell.Bottom - marginY, cell.Right + marginX, cell.Top + marginY);
+                var detailFit = Fit.Create(view, inner);
+                // Parts missing from the overview claim label space first.
+                var members = all.Where(index => CellOf(index) == (row, column))
+                    .OrderBy(index => failedSet.Contains(index) ? 0 : 1).ToList();
+                var detailLabels = PlaceLabels(plate, shapes, obstacles, members, detailFit,
+                    new XRect(0, 0, width, detailHeight), font, out var missed);
+                unplaced.AddRange(missed.Where(failedSet.Contains));
+                details.Add(new DiagramView(new XSize(width, detailHeight), detailFit, detailLabels, null,
+                    grid.Name(row, column), cell));
+            }
+            if (unplaced.Count == 0)
+                return new PlateDiagramPlan(new DiagramView(canvas, fit, labels, grid, null, null), details);
+        }
+
+        var worst = failed.First();
+        if (!legibleGrid)
+            throw new NotSupportedException($"Plate {plate.Number}, part {worst + 1} ({plate.Parts[worst].ReportId}): the part is too small relative to the sheet for a legible detail-view grid; this is not supported by the report.");
+        throw new NotSupportedException($"Plate {plate.Number}, part {worst + 1} ({plate.Parts[worst].ReportId}): its ID label cannot be placed legibly inside the part's material, even in a zoomed detail view; this is not supported by the report.");
+    }
+
+    /// <summary>Grid cell holding a part's bounds center; rows count down from the top.</summary>
+    private static (int Row, int Column) CellIndex(ReportPlate plate, int index, ReportBounds union, int columns, int rows)
+    {
+        var bounds = plate.Parts[index].Geometry.Bounds;
+        var x = (bounds.Left + bounds.Right) / 2;
+        var y = (bounds.Bottom + bounds.Top) / 2;
+        return (System.Math.Clamp((int)((union.Top - y) / (union.Width / rows)), 0, rows - 1),
+            System.Math.Clamp((int)((x - union.Left) / (union.Length / columns)), 0, columns - 1));
+    }
+
+    /// <summary>Grid spacing on the overview must exceed the gutter names it carries.</summary>
+    internal static bool GridIsLegible(DiagramGrid grid, Fit fit, XFont font)
+    {
+        var column = ReportText.Size(grid.Columns.ToString(System.Globalization.CultureInfo.InvariantCulture), font);
+        var row = ReportText.Size(ReportText.RowName(grid.Rows - 1), font);
+        return grid.CellLength * fit.Scale >= column.Width + 2 && grid.CellWidth * fit.Scale >= row.Height + 1
+            && row.Width + 2 <= GutterLeft && column.Height + 2 <= GutterTop;
+    }
+
+    /// <summary>
+    /// Centers each ID on its part's pole of inaccessibility (<see cref="PolyLabel"/>, as PlateView
+    /// does), so it sits deepest inside the material and clear of holes. A label box that would
+    /// touch an edge, hole, cutoff or another label is not moved elsewhere: the part fails here
+    /// and gets a zoomed detail view instead.
+    /// </summary>
+    private static List<DiagramLabel> PlaceLabels(ReportPlate plate, List<Shape> shapes, List<Shape> obstacles,
+        List<int> targets, Fit fit, XRect view, XFont font, out List<int> failed)
+    {
+        failed = [];
+        var placed = new List<DiagramLabel>();
+        foreach (var index in targets)
+        {
+            var id = plate.Parts[index].ReportId;
+            var size = ReportText.Size(id, font);
+            var width = size.Width + 2 * LabelPadding;
+            var height = size.Height + 2 * LabelPadding;
+            var pole = fit.Point(shapes[index].Pole.X, shapes[index].Pole.Y);
+            var box = new XRect(pole.X - width / 2, pole.Y - height / 2, width, height);
+            var topLeft = fit.Model(new XPoint(box.X - Clearance, box.Y - Clearance));
+            var bottomRight = fit.Model(new XPoint(box.Right + Clearance, box.Bottom + Clearance));
+            var test = new Box(topLeft.X, bottomRight.Y, bottomRight.X - topLeft.X, topLeft.Y - bottomRight.Y);
+            if (view.Contains(box) && !placed.Any(label => label.Box.IntersectsWith(box))
+                && !obstacles.Any(shape => shape.Crosses(test)))
+                placed.Add(new DiagramLabel(index, id, box));
+            else
+                failed.Add(index);
+        }
+        return placed;
+    }
+
+    /// <summary>Scale at which the label would fit the part's bounds, with room to avoid holes and strokes.</summary>
+    private static double RequiredScale(ReportPlate plate, int index, XFont font)
+    {
+        var bounds = plate.Parts[index].Geometry.Bounds;
+        if (!(bounds.Length > 0) || !(bounds.Width > 0))
+            throw new NotSupportedException($"Plate {plate.Number}, part {index + 1} ({plate.Parts[index].ReportId}): the part has no area to hold its ID label; this is not supported by the report.");
+        var size = ReportText.Size(plate.Parts[index].ReportId, font);
+        var scale = System.Math.Max((size.Width + 2 * (LabelPadding + Clearance)) / bounds.Length,
+            (size.Height + 2 * (LabelPadding + Clearance)) / bounds.Width) * 1.5;
+        if (!double.IsFinite(scale))
+            throw new NotSupportedException($"Plate {plate.Number}, part {index + 1} ({plate.Parts[index].ReportId}): the part is too small to hold a legible ID label.");
+        return scale;
+    }
+
+    private static ReportBounds Union(ReportPlate plate, IEnumerable<Shape> shapes)
+    {
+        var left = plate.Bounds.Left;
+        var bottom = plate.Bounds.Bottom;
+        var right = plate.Bounds.Right;
+        var top = plate.Bounds.Top;
+        foreach (var shape in shapes)
+        {
+            left = System.Math.Min(left, shape.Bounds.Left);
+            bottom = System.Math.Min(bottom, shape.Bounds.Bottom);
+            right = System.Math.Max(right, shape.Bounds.Right);
+            top = System.Math.Max(top, shape.Bounds.Top);
+        }
+        return new ReportBounds(left, bottom, right, top);
+    }
+
+    /// <summary>
+    /// Contours flattened with the same chord-tolerance routine as overlap/validation region
+    /// preparation, used only for label placement and never for drawing. Open contours are
+    /// closed here so a label cannot sit in a tab gap; rendering never closes them.
+    /// </summary>
+    private sealed class Shape
+    {
+        public Shape(ReportGeometry geometry)
+        {
+            Bounds = geometry.Bounds;
+            Box = new Box(Bounds.Left, Bounds.Bottom, Bounds.Length, Bounds.Width);
+            Rings = geometry.Contours.Select(contour => ClipperBridge.Flatten(ToShape(contour),
+                ChordTolerance(Bounds), circumscribe: false)).ToList();
+            lazyPole = new Lazy<Vector>(FindPole);
+        }
+
+        private readonly Lazy<Vector> lazyPole;
+
+        public ReportBounds Bounds { get; }
+
+        /// <summary>Pole of inaccessibility: the material point farthest from every edge.</summary>
+        public Vector Pole => lazyPole.Value;
+
+        private Box Box { get; }
+
+        private List<Polygon> Rings { get; }
+
+        /// <summary>
+        /// Like PlateView, which finds the pole once in the drawing's own frame, search a
+        /// placement-independent copy: symmetric shapes (a square with a central hole) have
+        /// several equally deep poles, and sheet-position roundoff must not pick different ones
+        /// for identical parts. Largest ring is the perimeter, the rest holes (ShapeProfile's rule).
+        /// </summary>
+        private Vector FindPole()
+        {
+            if (Rings.Count == 0)
+                return new Vector();
+            var grain = System.Math.Max(Bounds.Length, Bounds.Width) * 1e-9;
+            Polygon Local(Polygon ring)
+            {
+                var local = new Polygon();
+                local.Vertices.AddRange(ring.Vertices.Select(vertex => new Vector(
+                    System.Math.Round((vertex.X - Bounds.Left) / grain) * grain,
+                    System.Math.Round((vertex.Y - Bounds.Bottom) / grain) * grain)));
+                return local;
+            }
+            var ordered = Rings.OrderByDescending(ring => ring.Area()).Select(Local).ToList();
+            var pole = PolyLabel.Find(ordered[0], ordered.Skip(1).ToList(), PolePrecision(Bounds));
+            return new Vector(pole.X + Bounds.Left, pole.Y + Bounds.Bottom);
+        }
+
+        /// <summary>Whether any contour edge lies in or crosses the model-space rectangle.</summary>
+        public bool Crosses(Box box)
+        {
+            if (!Box.Intersects(box))
+                return false;
+            var outline = new Polygon();
+            outline.Vertices.AddRange([new Vector(box.Left, box.Bottom), new Vector(box.Right, box.Bottom),
+                new Vector(box.Right, box.Top), new Vector(box.Left, box.Top)]);
+            outline.Close();
+            return Rings.Any(ring => ring.Vertices.Any(box.Contains) || ring.Intersects(outline));
+        }
+
+        private static OpenNest.Geometry.Shape ToShape(ReportContour contour)
+        {
+            var shape = new OpenNest.Geometry.Shape();
+            foreach (var segment in contour.Segments)
+            {
+                if (segment.Center == null)
+                {
+                    shape.Entities.Add(new Line(ToVector(segment.Start), ToVector(segment.End)));
+                    continue;
+                }
+                var center = ToVector(segment.Center);
+                if (System.Math.Abs(segment.SweepAngle) >= 2 * System.Math.PI)
+                {
+                    shape.Entities.Add(new Circle(center, segment.Radius)
+                    {
+                        Rotation = segment.SweepAngle < 0 ? RotationType.CW : RotationType.CCW,
+                    });
+                    continue;
+                }
+                // A reversed arc runs from StartAngle toward the (smaller) EndAngle.
+                shape.Entities.Add(new Arc(center, segment.Radius, segment.StartAngle,
+                    segment.StartAngle + segment.SweepAngle, reversed: segment.SweepAngle < 0));
+            }
+            return shape;
+        }
+
+        private static Vector ToVector(ReportPoint point) => new(point.X, point.Y);
+    }
+}
+
+/// <summary>One aspect-preserving model-to-canvas transform, centered, with the Y axis flipped.</summary>
+internal readonly record struct Fit(ReportBounds Bounds, double Scale, double X, double Y)
+{
+    public static Fit Create(ReportBounds bounds, XRect area)
+    {
+        var scales = new List<double>(2);
+        if (bounds.Length > 0)
+            scales.Add(area.Width / bounds.Length);
+        if (bounds.Width > 0)
+            scales.Add(area.Height / bounds.Width);
+        var scale = scales.Count == 0 ? 1 : scales.Min();
+        if (!double.IsFinite(scale) || scale <= 0)
+            throw new InvalidOperationException("Report geometry cannot be fitted to the page.");
+        return new Fit(bounds, scale,
+            area.X + (area.Width - bounds.Length * scale) / 2,
+            area.Y + (area.Height - bounds.Width * scale) / 2);
+    }
+
+    public XPoint Point(ReportPoint point) => Point(point.X, point.Y);
+
+    public XPoint Point(double x, double y) => new(X + (x - Bounds.Left) * Scale, Y + (Bounds.Top - y) * Scale);
+
+    public XPoint Model(XPoint local) => new(Bounds.Left + (local.X - X) / Scale, Bounds.Top - (local.Y - Y) / Scale);
+
+    public XRect Rect(ReportBounds box)
+    {
+        var low = Point(box.Left, box.Top);
+        return new XRect(low.X, low.Y, box.Length * Scale, box.Width * Scale);
+    }
+}

OpenNest.Reporting/NestReportGeometry.cs

@@ -0,0 +1,174 @@
+using System.Collections.Immutable;
+using OpenNest.CNC;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest.Reporting;
+
+internal static class NestReportGeometry
+{
+    internal static ReportGeometry Capture(Program? program, Vector location, string context)
+    {
+        ValidatePoint(location, context);
+        var current = new Vector();
+        // ConvertProgram recurses without cycle/null guards and silently skips unknown codes.
+        // Validate first; never clone through SubProgramCall's rotating setters.
+        ValidateProgram(program, ref current, new HashSet<Program>(ReferenceEqualityComparer.Instance), context);
+        var entities = ConvertProgram.ToGeometry(program!);
+        var contours = ImmutableArray.CreateBuilder<ReportContour>();
+        var segments = ImmutableArray.CreateBuilder<ReportSegment>();
+        var left = double.PositiveInfinity;
+        var bottom = double.PositiveInfinity;
+        var right = double.NegativeInfinity;
+        var top = double.NegativeInfinity;
+
+        void Flush()
+        {
+            if (segments.Count == 0)
+                return;
+            var closed = SamePoint(segments[0].Start, segments[^1].End);
+            contours.Add(new ReportContour(segments.ToImmutable(), closed));
+            segments.Clear();
+        }
+
+        foreach (var entity in entities)
+        {
+            if (!SpecialLayers.IsMaterial(entity.Layer)
+                || entity.Layer == SpecialLayers.Leadin || entity.Layer == SpecialLayers.Leadout)
+            {
+                Flush();
+                continue;
+            }
+
+            ReportSegment segment;
+            switch (entity)
+            {
+                case Line line:
+                    if (line.StartPoint.X == line.EndPoint.X && line.StartPoint.Y == line.EndPoint.Y)
+                        continue;
+                    segment = new ReportSegment(Point(line.StartPoint, location, context),
+                        Point(line.EndPoint, location, context), null, 0, 0, 0);
+                    break;
+                case Arc arc:
+                    segment = new ReportSegment(Point(arc.StartPoint(), location, context),
+                        Point(arc.EndPoint(), location, context), Point(arc.Center, location, context),
+                        arc.Radius, arc.StartAngle, arc.SweepAngle() * (arc.IsReversed ? -1 : 1));
+                    break;
+                case Circle circle:
+                    Flush();
+                    var start = Point(new Vector(circle.Center.X + circle.Radius, circle.Center.Y), location, context);
+                    segment = new ReportSegment(start, start, Point(circle.Center, location, context),
+                        circle.Radius, 0, circle.Rotation == RotationType.CW ? -2 * System.Math.PI : 2 * System.Math.PI);
+                    break;
+                default:
+                    throw Error(context, $"unsupported geometry '{entity.GetType().Name}'.");
+            }
+
+            if (segment.Center != null && (!double.IsFinite(segment.Radius) || segment.Radius <= 0
+                || !double.IsFinite(segment.StartAngle) || !double.IsFinite(segment.SweepAngle)
+                || segment.SweepAngle == 0 || System.Math.Abs(segment.SweepAngle) > 2 * System.Math.PI))
+                throw Error(context, "invalid arc/circle data.");
+            if (segments.Count > 0 && !SamePoint(segments[^1].End, segment.Start))
+                Flush();
+            segments.Add(segment);
+            if (SamePoint(segments[0].Start, segment.End))
+                Flush();
+
+            var box = entity.BoundingBox;
+            var low = Point(new Vector(box.Left, box.Bottom), location, context);
+            var high = Point(new Vector(box.Right, box.Top), location, context);
+            left = System.Math.Min(left, low.X);
+            bottom = System.Math.Min(bottom, low.Y);
+            right = System.Math.Max(right, high.X);
+            top = System.Math.Max(top, high.Y);
+        }
+        Flush();
+        if (contours.Count == 0)
+            throw Error(context, "missing drawable material geometry.");
+        if (!double.IsFinite(right - left) || !double.IsFinite(top - bottom))
+            throw Error(context, "geometry bounds are not finite.");
+        return new ReportGeometry(contours.ToImmutable(), new ReportBounds(left, bottom, right, top));
+    }
+
+    private static void ValidateProgram(Program? program, ref Vector current,
+        HashSet<Program> active, string context)
+    {
+        if (program?.Codes == null)
+            throw Error(context, "missing program or subprogram reference.");
+        if (!active.Add(program))
+            throw Error(context, "cyclic subprogram reference.");
+        if (active.Count > 256)
+            throw Error(context, "unsupported subprogram nesting depth (maximum 256).");
+        if (!double.IsFinite(program.Rotation) || !Enum.IsDefined(program.Mode))
+            throw Error(context, "invalid program transform or coordinate mode.");
+        var origin = current;
+        for (var index = 0; index < program.Codes.Count; index++)
+        {
+            var code = program.Codes[index];
+            var codeContext = $"{context}, code {index + 1}";
+            switch (code)
+            {
+                case SubProgramCall call when code.Type == CodeType.SubProgramCall:
+                    ValidatePoint(call.Offset, codeContext);
+                    if (!double.IsFinite(call.Rotation))
+                        throw Error(codeContext, "invalid subprogram rotation.");
+                    current = origin + call.Offset;
+                    ValidatePoint(current, codeContext);
+                    ValidateProgram(call.Program, ref current, active, $"{codeContext}, subprogram {call.Id}");
+                    break;
+                case Motion motion when code is LinearMove && code.Type == CodeType.LinearMove
+                    || code is RapidMove && code.Type == CodeType.RapidMove
+                    || code is ArcMove && code.Type == CodeType.ArcMove:
+                    ValidatePoint(motion.EndPoint, codeContext);
+                    var end = program.Mode == Mode.Incremental ? current + motion.EndPoint : motion.EndPoint;
+                    ValidatePoint(end, codeContext);
+                    if (motion is LinearMove linear && !Enum.IsDefined(linear.Layer))
+                        throw Error(codeContext, "unsupported material layer.");
+                    if (motion is ArcMove arc)
+                    {
+                        ValidatePoint(arc.CenterPoint, codeContext);
+                        if (!Enum.IsDefined(arc.Rotation) || !Enum.IsDefined(arc.Layer))
+                            throw Error(codeContext, "invalid arc rotation or layer.");
+                        var center = program.Mode == Mode.Incremental ? current + arc.CenterPoint : arc.CenterPoint;
+                        ValidatePoint(center, codeContext);
+                        var startRadius = current.DistanceTo(center);
+                        var endRadius = end.DistanceTo(center);
+                        if (!double.IsFinite(startRadius) || !double.IsFinite(endRadius)
+                            || startRadius <= 0 || endRadius <= 0
+                            || System.Math.Abs(startRadius - endRadius) > Tolerance.Epsilon)
+                            throw Error(codeContext, "invalid arc/circle radius or inconsistent endpoints.");
+                    }
+                    current = end;
+                    break;
+                case Comment when code.Type == CodeType.Comment:
+                case Feedrate when code.Type == CodeType.SetFeedrate:
+                case Kerf when code.Type == CodeType.SetKerf:
+                    break;
+                default:
+                    throw Error(codeContext, code == null ? "missing code." : $"unsupported code '{code.GetType().Name}'.");
+            }
+        }
+        active.Remove(program);
+    }
+
+    private static ReportPoint Point(Vector point, Vector location, string context)
+    {
+        var translated = point + location;
+        ValidatePoint(translated, context);
+        return new ReportPoint(translated.X, translated.Y);
+    }
+
+    private static void ValidatePoint(Vector point, string context)
+    {
+        if (!double.IsFinite(point.X) || !double.IsFinite(point.Y))
+            throw Error(context, "nonfinite geometry coordinate.");
+    }
+
+    // Only absorb floating-point trig roundoff, never ShapeBuilder's welding tolerance.
+    // A deliberate tab/rapid interruption is never joined by contour construction.
+    private static bool SamePoint(ReportPoint first, ReportPoint second) =>
+        System.Math.Abs(first.X - second.X) <= 1e-12 && System.Math.Abs(first.Y - second.Y) <= 1e-12;
+
+    private static InvalidOperationException Error(string context, string message) => new($"{context}: {message}");
+}

OpenNest.Reporting/NestReportSnapshot.cs

@@ -0,0 +1,38 @@
+using System.Collections.Immutable;
+
+namespace OpenNest.Reporting;
+
+public sealed record ReportPoint(double X, double Y);
+
+public sealed record ReportBounds(double Left, double Bottom, double Right, double Top)
+{
+    public double Length => Right - Left;
+    public double Width => Top - Bottom;
+}
+
+/// <summary>Native line or arc; angles are radians and a null center denotes a line.</summary>
+public sealed record ReportSegment(ReportPoint Start, ReportPoint End, ReportPoint? Center,
+    double Radius, double StartAngle, double SweepAngle);
+
+public sealed record ReportContour(ImmutableArray<ReportSegment> Segments, bool Closed);
+
+public sealed record ReportGeometry(ImmutableArray<ReportContour> Contours, ReportBounds Bounds)
+{
+    public bool StrokeOnly => Contours.Any(contour => !contour.Closed);
+}
+
+public sealed record ReportDrawing(string Id, string Name, long Required, long Nested,
+    long Shortage, long Extra, ImmutableArray<int> Plates, ReportGeometry Geometry);
+
+public sealed record ReportPlacement(string ReportId, ReportGeometry Geometry);
+
+public sealed record ReportPlate(int Number, ReportBounds Bounds, int Copies, double PartSpacing,
+    double Utilization, ImmutableArray<ReportPlacement> Parts, ImmutableArray<ReportGeometry> Cutoffs);
+
+/// <summary>A detached value snapshot. No domain objects or mutable geometry are retained.</summary>
+public sealed record NestReportSnapshot(string Name, string Customer, string Notes, string Material,
+    string Grade, double Thickness, string Units, DateTimeOffset GeneratedAt,
+    ImmutableArray<ReportDrawing> Drawings, ImmutableArray<ReportPlate> Plates)
+{
+    public long TotalSheets => Plates.Aggregate(0L, (total, plate) => checked(total + plate.Copies));
+}

OpenNest.Reporting/OpenNest.Reporting.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />
+    <PackageReference Include="PDFsharp-MigraDoc" Version="6.2.4" />
+    <EmbeddedResource Include="Fonts\*.ttf" />
+    <None Update="Fonts\LICENSE.txt;THIRD-PARTY-NOTICES.txt" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="PreserveNewest" TargetPath="ReportingNotices\%(Filename)%(Extension)" />
+    <InternalsVisibleTo Include="OpenNest.Tests" />
+  </ItemGroup>
+</Project>

OpenNest.Reporting/ReportFonts.cs

@@ -0,0 +1,59 @@
+using PdfSharp.Fonts;
+
+namespace OpenNest.Reporting;
+
+/// <summary>Process-wide, embedded fonts; never consult platform font directories.</summary>
+internal static class ReportFonts
+{
+    internal const string Family = "OpenNest Report Sans";
+    private static readonly object Sync = new();
+    private static readonly BundledResolver Resolver = new();
+
+    internal static void Initialize()
+    {
+        lock (Sync)
+        {
+            if (GlobalFontSettings.FontResolver == null)
+                GlobalFontSettings.FontResolver = Resolver;
+            else if (!ReferenceEquals(GlobalFontSettings.FontResolver, Resolver))
+                throw new InvalidOperationException("Nest reports require their bundled font resolver before PDF fonts are created. Another resolver is already installed.");
+            // MigraDoc otherwise asks the resolver for a platform "Courier New" error font.
+            MigraDoc.PredefinedFontsAndChars.ErrorFontName = Family;
+        }
+    }
+
+    internal static void ValidateText(string text, string field)
+    {
+        // Slice 1 deliberately supports printable Latin-1, not general Unicode shaping.
+        // Reject unavailable text explicitly instead of substituting .notdef boxes or hiding it.
+        foreach (var rune in text.EnumerateRunes())
+        {
+            var value = rune.Value;
+            if (value is '\r' or '\n' or '\t' || value is >= 0x20 and <= 0x7e
+                || value is >= 0xa0 and <= 0xff && value != 0xad)
+                continue;
+            throw new InvalidOperationException($"{field}: unsupported report character U+{value:X4}. This report slice supports printable Latin-1 text only.");
+        }
+    }
+
+    private sealed class BundledResolver : IFontResolver
+    {
+        public FontResolverInfo? ResolveTypeface(string familyName, bool isBold, bool isItalic)
+        {
+            if (!string.Equals(familyName, Family, StringComparison.OrdinalIgnoreCase) || isItalic)
+                return null;
+            return new FontResolverInfo(isBold ? "DejaVuSans-Bold" : "DejaVuSans");
+        }
+
+        public byte[] GetFont(string faceName)
+        {
+            if (faceName is not ("DejaVuSans" or "DejaVuSans-Bold"))
+                throw new InvalidOperationException($"Unknown report font face: {faceName}.");
+            using var source = typeof(ReportFonts).Assembly.GetManifestResourceStream($"OpenNest.Reporting.Fonts.{faceName}.ttf")
+                ?? throw new InvalidOperationException($"Bundled report font missing: {faceName}.");
+            using var bytes = new MemoryStream();
+            source.CopyTo(bytes);
+            return bytes.ToArray();
+        }
+    }
+}

OpenNest.Reporting/ReportText.cs

@@ -0,0 +1,122 @@
+using System.Globalization;
+using System.Text;
+using PdfSharp.Drawing;
+
+namespace OpenNest.Reporting;
+
+/// <summary>
+/// Lossless pre-wrapping. MigraDoc lets an unbroken token overflow a table cell and silently
+/// clips a row taller than the page, so cell text is wrapped here and bounded before layout.
+/// </summary>
+internal static class ReportText
+{
+    /// <summary>Line cap for one table cell; taller rows would be clipped by MigraDoc.</summary>
+    internal const int MaxCellLines = 20;
+
+    // Headless measurement only; PDF output uses the same bundled font metrics.
+    private static readonly XGraphics Measure = XGraphics.CreateMeasureContext(
+        new XSize(2000, 2000), XGraphicsUnit.Point, XPageDirection.Downwards);
+    private static readonly object Sync = new();
+
+    internal static XSize Size(string text, XFont font)
+    {
+        lock (Sync)
+            return Measure.MeasureString(text, font);
+    }
+
+    /// <summary>
+    /// Splits explicit line breaks, then wraps at spaces, and breaks tokens wider than
+    /// <paramref name="width"/> between characters. Only the space at a wrap point is consumed.
+    /// </summary>
+    internal static List<string> Wrap(string text, XFont font, double width)
+    {
+        // Leave slack so MigraDoc does not re-break an already fitted line.
+        var limit = width - 1;
+        var lines = new List<string>();
+        foreach (var hard in text.Replace("\r\n", "\n").Replace('\r', '\n').Replace('\t', ' ').Split('\n'))
+        {
+            var line = new StringBuilder();
+            foreach (var word in hard.Split(' '))
+            {
+                var candidate = line.Length == 0 ? word : line + " " + word;
+                if (Size(candidate, font).Width <= limit)
+                {
+                    line.Clear().Append(candidate);
+                    continue;
+                }
+                if (line.Length > 0)
+                {
+                    lines.Add(line.ToString());
+                    line.Clear();
+                }
+                var rest = word;
+                while (Size(rest, font).Width > limit)
+                {
+                    var take = FittingPrefix(rest, font, limit);
+                    lines.Add(rest[..take]);
+                    rest = rest[take..];
+                }
+                line.Append(rest);
+            }
+            lines.Add(line.ToString());
+        }
+        return lines;
+    }
+
+    /// <summary>Wraps table-cell text and rejects a row MigraDoc could not show completely.</summary>
+    internal static List<string> Cell(string text, XFont font, double width, string field)
+    {
+        var lines = Wrap(text, font, width);
+        if (lines.Count > MaxCellLines)
+            throw new NotSupportedException($"{field}: text needs {lines.Count} lines in its table cell; this report supports at most {MaxCellLines}.");
+        return lines;
+    }
+
+    /// <summary>Compresses ascending plate numbers losslessly, e.g. "1-3, 5".</summary>
+    internal static string Ranges(IReadOnlyList<int> numbers)
+    {
+        if (numbers.Count == 0)
+            return "-";
+        var parts = new List<string>();
+        var start = numbers[0];
+        var previous = start;
+        for (var index = 1; index <= numbers.Count; index++)
+        {
+            if (index < numbers.Count && numbers[index] == previous + 1)
+            {
+                previous = numbers[index];
+                continue;
+            }
+            parts.Add(start == previous
+                ? start.ToString(CultureInfo.InvariantCulture)
+                : $"{start.ToString(CultureInfo.InvariantCulture)}-{previous.ToString(CultureInfo.InvariantCulture)}");
+            if (index < numbers.Count)
+                start = previous = numbers[index];
+        }
+        return string.Join(", ", parts);
+    }
+
+    /// <summary>Map-style row names: A..Z, AA, AB, ...</summary>
+    internal static string RowName(int index)
+    {
+        var name = "";
+        for (var value = index + 1; value > 0; value = (value - 1) / 26)
+            name = (char)('A' + (value - 1) % 26) + name;
+        return name;
+    }
+
+    private static int FittingPrefix(string text, XFont font, double limit)
+    {
+        // At least one character always advances, even if a single glyph is wider than the cell.
+        int low = 1, high = text.Length - 1;
+        while (low < high)
+        {
+            var middle = (low + high + 1) / 2;
+            if (Size(text[..middle], font).Width <= limit)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        return low;
+    }
+}

OpenNest.Server/Dockerfile

@@ -0,0 +1,23 @@
+# Build from the repository root: docker build -f OpenNest.Server/Dockerfile -t opennest-server .
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+
+COPY OpenNest.Server/OpenNest.Server.csproj OpenNest.Server/
+COPY OpenNest.Data/OpenNest.Data.csproj OpenNest.Data/
+RUN dotnet restore OpenNest.Server/OpenNest.Server.csproj
+
+COPY OpenNest.Server/ OpenNest.Server/
+COPY OpenNest.Data/ OpenNest.Data/
+RUN dotnet publish OpenNest.Server/OpenNest.Server.csproj -c Release -o /app --no-restore
+
+FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
+WORKDIR /app
+COPY --from=build /app .
+
+# SQLite database + .nest blobs live here; mount a volume at this path.
+VOLUME /app/data
+ENV OPENNEST_DB=/app/data/nests.db
+ENV ASPNETCORE_URLS=http://+:8090
+EXPOSE 8090
+
+ENTRYPOINT ["dotnet", "OpenNest.Server.dll"]

OpenNest.Server/NestDatabase.cs

@@ -0,0 +1,180 @@
+using Microsoft.Data.Sqlite;
+using OpenNest.Data;
+
+namespace OpenNest.Server;
+
+/// <summary>
+/// SQLite-backed nest storage: metadata columns plus the .nest archive as a BLOB.
+/// The database is created on first use. Records are keyed by client-generated ids
+/// so a PC that loses its local id mapping can still re-upload under a new id;
+/// updates keep the id.
+/// </summary>
+public sealed class NestDatabase : IDisposable
+{
+    private readonly SqliteConnection _connection;
+
+    public NestDatabase(string databasePath)
+    {
+        var directory = Path.GetDirectoryName(Path.GetFullPath(databasePath));
+        if (!string.IsNullOrEmpty(directory))
+            Directory.CreateDirectory(directory);
+
+        _connection = new SqliteConnection($"Data Source={databasePath}");
+        _connection.Open();
+        Execute("""
+            PRAGMA journal_mode=WAL;
+            CREATE TABLE IF NOT EXISTS nests (
+                id           TEXT PRIMARY KEY,
+                name         TEXT NOT NULL,
+                customer     TEXT NOT NULL DEFAULT '',
+                dateCreated  TEXT NOT NULL,
+                dateModified TEXT NOT NULL,
+                material     TEXT NOT NULL DEFAULT '',
+                thickness    REAL NOT NULL DEFAULT 0,
+                status       TEXT NOT NULL DEFAULT 'Quote',
+                plateCount   INTEGER NOT NULL DEFAULT 0,
+                partCount    INTEGER NOT NULL DEFAULT 0,
+                comments     TEXT NOT NULL DEFAULT '',
+                madeBy       TEXT NOT NULL DEFAULT '',
+                fileSize     INTEGER NOT NULL DEFAULT 0,
+                savedAt      TEXT NOT NULL,
+                file         BLOB NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS ix_nests_savedAt ON nests(savedAt DESC);
+            """);
+    }
+
+    public IReadOnlyList<NestRecord> List()
+    {
+        using var command = _connection.CreateCommand();
+        command.CommandText =
+            $"SELECT {RecordColumns} FROM nests ORDER BY savedAt DESC";
+        var records = new List<NestRecord>();
+        using var reader = command.ExecuteReader();
+        while (reader.Read())
+            records.Add(ReadRecord(reader));
+        return records;
+    }
+
+    public NestRecord? Get(Guid id)
+    {
+        using var command = _connection.CreateCommand();
+        command.CommandText = $"SELECT {RecordColumns} FROM nests WHERE id = $id";
+        command.Parameters.AddWithValue("$id", id.ToString());
+        using var reader = command.ExecuteReader();
+        return reader.Read() ? ReadRecord(reader) : null;
+    }
+
+    public byte[]? GetFile(Guid id)
+    {
+        using var command = _connection.CreateCommand();
+        command.CommandText = "SELECT file FROM nests WHERE id = $id";
+        command.Parameters.AddWithValue("$id", id.ToString());
+        var value = command.ExecuteScalar();
+        return value is byte[] bytes ? bytes : null;
+    }
+
+    public NestRecord Insert(Guid id, NestRecord record, byte[] file)
+    {
+        using var command = _connection.CreateCommand();
+        command.CommandText = """
+            INSERT INTO nests (id, name, customer, dateCreated, dateModified, material,
+                thickness, status, plateCount, partCount, comments, madeBy, fileSize,
+                savedAt, file)
+            VALUES ($id, $name, $customer, $dateCreated, $dateModified, $material,
+                $thickness, $status, $plateCount, $partCount, $comments, $madeBy,
+                $fileSize, $savedAt, $file)
+            """;
+        AddRecordParameters(command, id, record, file, updateFile: true);
+        command.ExecuteNonQuery();
+        return Get(id) ?? throw new InvalidOperationException("Insert did not persist.");
+    }
+
+    public NestRecord? Update(Guid id, NestRecord record, byte[]? file)
+    {
+        if (Get(id) is null)
+            return null;
+
+        using var command = _connection.CreateCommand();
+        var fileClause = file is null ? "" : ", file = $file, fileSize = $fileSize";
+        command.CommandText = $"""
+            UPDATE nests SET
+                name = $name, customer = $customer, dateCreated = $dateCreated,
+                dateModified = $dateModified, material = $material,
+                thickness = $thickness, status = $status, plateCount = $plateCount,
+                partCount = $partCount, comments = $comments, madeBy = $madeBy,
+                savedAt = $savedAt{fileClause}
+            WHERE id = $id
+            """;
+        AddRecordParameters(command, id, record, file, updateFile: file is not null);
+        command.ExecuteNonQuery();
+        return Get(id);
+    }
+
+    public bool Delete(Guid id)
+    {
+        using var command = _connection.CreateCommand();
+        command.CommandText = "DELETE FROM nests WHERE id = $id";
+        command.Parameters.AddWithValue("$id", id.ToString());
+        return command.ExecuteNonQuery() > 0;
+    }
+
+    public void Dispose() => _connection.Dispose();
+
+    private void Execute(string sql)
+    {
+        using var command = _connection.CreateCommand();
+        command.CommandText = sql;
+        command.ExecuteNonQuery();
+    }
+
+    private const string RecordColumns = """
+        id, name, customer, dateCreated, dateModified, material, thickness,
+        status, plateCount, partCount, comments, madeBy, fileSize, savedAt
+        """;
+
+    private static void AddRecordParameters(
+        SqliteCommand command, Guid id, NestRecord record, byte[]? file, bool updateFile)
+    {
+        command.Parameters.AddWithValue("$id", id.ToString());
+        command.Parameters.AddWithValue("$name", record.Name);
+        command.Parameters.AddWithValue("$customer", record.Customer);
+        command.Parameters.AddWithValue("$dateCreated", record.DateCreated.ToString("o"));
+        command.Parameters.AddWithValue("$dateModified", record.DateModified.ToString("o"));
+        command.Parameters.AddWithValue("$material", record.Material);
+        command.Parameters.AddWithValue("$thickness", record.Thickness);
+        command.Parameters.AddWithValue("$status", record.Status.ToString());
+        command.Parameters.AddWithValue("$plateCount", record.PlateCount);
+        command.Parameters.AddWithValue("$partCount", record.PartCount);
+        command.Parameters.AddWithValue("$comments", record.Comments);
+        command.Parameters.AddWithValue("$madeBy", record.MadeBy);
+        command.Parameters.AddWithValue("$savedAt", DateTime.Now.ToString("o"));
+        if (updateFile)
+        {
+            command.Parameters.AddWithValue("$file", file!);
+            command.Parameters.AddWithValue("$fileSize", file!.LongLength);
+        }
+    }
+
+    private static NestRecord ReadRecord(SqliteDataReader reader)
+    {
+        return new NestRecord
+        {
+            Id = Guid.Parse(reader.GetString(0)),
+            Name = reader.GetString(1),
+            Customer = reader.GetString(2),
+            DateCreated = DateTime.Parse(reader.GetString(3)),
+            DateModified = DateTime.Parse(reader.GetString(4)),
+            Material = reader.GetString(5),
+            Thickness = reader.GetDouble(6),
+            Status = Enum.TryParse<NestStatus>(reader.GetString(7), true, out var s)
+                ? s : NestStatus.Quote,
+            PlateCount = (int)reader.GetInt64(8),
+            PartCount = (int)reader.GetInt64(9),
+            Comments = reader.GetString(10),
+            MadeBy = reader.GetString(11),
+            FileSize = reader.GetInt64(12),
+            SavedAt = DateTime.Parse(reader.GetString(13)),
+        };
+    }
+}

OpenNest.Server/OpenNest.Server.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>OpenNest.Server</RootNamespace>
+    <AssemblyName>OpenNest.Server</AssemblyName>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Data.Sqlite" Version="8.0.11" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\OpenNest.Data\OpenNest.Data.csproj" />
+  </ItemGroup>
+
+</Project>

OpenNest.Server/Program.cs

@@ -0,0 +1,129 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using OpenNest.Data;
+using OpenNest.Server;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Same wire contract as RemoteNestRepository: camelCase, enum-as-string.
+var jsonOptions = new JsonSerializerOptions(JsonSerializerDefaults.Web)
+{
+    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    PropertyNameCaseInsensitive = true,
+    Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) },
+};
+builder.Services.ConfigureHttpJsonOptions(options =>
+{
+    options.SerializerOptions.PropertyNamingPolicy = jsonOptions.PropertyNamingPolicy;
+    options.SerializerOptions.PropertyNameCaseInsensitive = true;
+    foreach (var converter in jsonOptions.Converters)
+        options.SerializerOptions.Converters.Add(converter);
+});
+
+// Storage path: --database <path> or OPENNEST_DB, default ./data/nests.db (a Docker volume).
+var databasePath =
+    args.FirstOrDefault(a => a.StartsWith("--database=", StringComparison.Ordinal))?.Split('=', 2)[1]
+    ?? Environment.GetEnvironmentVariable("OPENNEST_DB")
+    ?? Path.Combine("data", "nests.db");
+builder.Services.AddSingleton(new NestDatabase(databasePath));
+
+// Listen port: --urls or ASPNETCORE_URLS; Dockerfile defaults to 8090.
+var app = builder.Build();
+
+app.MapGet("/healthz", () => Results.Ok(new { status = "ok" }));
+
+app.MapGet("/api/nests", (NestDatabase db) => Results.Ok(db.List()));
+
+app.MapGet("/api/nests/{id:guid}", (Guid id, NestDatabase db) =>
+    db.Get(id) is { } record ? Results.Ok(record) : Results.NotFound());
+
+app.MapGet("/api/nests/{id:guid}/file", (Guid id, NestDatabase db) =>
+    db.GetFile(id) is { } file ? Results.File(file, "application/zip", $"{id}.nest") : Results.NotFound());
+
+// POST/PUT multipart: "metadata" JSON part + "file" part (the .nest archive).
+app.MapPost("/api/nests", async (HttpContext http, NestDatabase db) =>
+{
+    var (record, file, error) = await ReadMultipart(http);
+    if (error is not null)
+        return error;
+
+    var id = record!.Id == Guid.Empty ? Guid.NewGuid() : record.Id;
+    return Results.Ok(db.Insert(id, record, file!));
+});
+app.MapPut("/api/nests/{id:guid}/file", async (Guid id, HttpContext http, NestDatabase db) =>
+{
+    var (record, file, error) = await ReadMultipart(http);
+    if (error is not null)
+        return error;
+
+    var updated = db.Update(id, record!, file);
+    return updated is null ? Results.NotFound() : Results.Ok(updated);
+});
+
+app.MapPut("/api/nests/{id:guid}/metadata", async (Guid id, HttpContext http, NestDatabase db) =>
+{
+    NestRecord? record;
+    try
+    {
+        record = await http.Request.ReadFromJsonAsync<NestRecord>();
+    }
+    catch (JsonException)
+    {
+        return Results.BadRequest("Invalid metadata JSON.");
+    }
+
+    if (record is null)
+        return Results.BadRequest("Missing metadata.");
+
+    // Keep the stored archive's size; metadata updates never touch the file.
+    var updated = db.Update(id, record, file: null);
+    return updated is null ? Results.NotFound() : Results.Ok(updated);
+});
+
+app.MapDelete("/api/nests/{id:guid}", (Guid id, NestDatabase db) =>
+    db.Delete(id) ? Results.NoContent() : Results.NotFound());
+
+app.Run();
+
+// Shared multipart reader for upload endpoints. Returns a (record, file, error) triple.
+static async Task<(NestRecord? Record, byte[]? File, IResult? Error)> ReadMultipart(HttpContext http)
+{
+    if (!http.Request.HasFormContentType)
+        return (null, null, Results.BadRequest("Expected multipart/form-data with metadata and file parts."));
+
+    var form = await http.Request.ReadFormAsync();
+    var metadataPart = form["metadata"].FirstOrDefault();
+    if (string.IsNullOrWhiteSpace(metadataPart))
+        return (null, null, Results.BadRequest("Missing 'metadata' part."));
+
+    NestRecord? record;
+    try
+    {
+        record = JsonSerializer.Deserialize<NestRecord>(metadataPart, MultipartJson.Options);
+    }
+    catch (JsonException)
+    {
+        return (null, null, Results.BadRequest("Invalid metadata JSON."));
+    }
+
+    if (record is null)
+        return (null, null, Results.BadRequest("Missing metadata."));
+
+    var filePart = form.Files["file"];
+    if (filePart is null || filePart.Length == 0)
+        return (null, null, Results.BadRequest("Missing or empty 'file' part."));
+
+    using var stream = filePart.OpenReadStream();
+    using var buffer = new MemoryStream((int)filePart.Length);
+    await stream.CopyToAsync(buffer);
+    return (record, buffer.ToArray(), null);
+}
+
+internal static class MultipartJson
+{
+    public static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web)
+    {
+        PropertyNameCaseInsensitive = true,
+        Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) },
+    };
+}

OpenNest.Tests/CNC/PlateRapidEnumeratorTests.cs

@@ -0,0 +1,141 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using OpenNest.IO;
+
+namespace OpenNest.Tests.CNC;
+
+public class PlateRapidEnumeratorTests
+{
+    [Theory]
+    [InlineData(1, CutDirection.AwayFromOrigin)]
+    [InlineData(2, CutDirection.AwayFromOrigin)]
+    [InlineData(3, CutDirection.AwayFromOrigin)]
+    [InlineData(4, CutDirection.AwayFromOrigin)]
+    [InlineData(1, CutDirection.TowardOrigin)]
+    [InlineData(2, CutDirection.TowardOrigin)]
+    [InlineData(3, CutDirection.TowardOrigin)]
+    [InlineData(4, CutDirection.TowardOrigin)]
+    public void Enumerate_AppliedAutomaticCutoffs_ConnectsFromFinalCut(int quadrant, CutDirection direction)
+    {
+        var program = new Program();
+        program.Codes.Add(new RapidMove(0, 0));
+        program.Codes.Add(new LinearMove(70, 0));
+        program.Codes.Add(new LinearMove(70, 20));
+        program.Codes.Add(new LinearMove(0, 20));
+        program.Codes.Add(new LinearMove(0, 0));
+        var drawing = new Drawing("rectangle", program);
+        var plate = new Plate(81, 120) { Quadrant = quadrant, PartSpacing = 0.5 };
+        plate.Parts.Add(new Part(drawing,
+            new Vector(quadrant is 2 or 3 ? -80 : 10, quadrant is 3 or 4 ? -40 : 20)));
+        var settings = new CutOffSettings { CutDirection = direction, Overtravel = 2 };
+        var plan = AutomaticCutOffPlanner.Create(plate, new AutomaticCutOffOptions { Spacing = 35 }, settings);
+        Assert.False(plan.HasBlockingDiagnostics);
+        Assert.Equal(3, plan.Definitions.Count);
+        foreach (var definition in plan.Definitions)
+            plate.CutOffs.Add(definition);
+        plate.RegenerateCutOffs(settings);
+
+        // Two interrupted skeleton cuts followed by an uninterrupted tail separator.
+        var cutoffs = plate.Parts.Where(p => p.BaseDrawing.IsCutOff).ToArray();
+        Assert.Equal(new[] { 2, 2, 1 }, cutoffs.Select(p => p.Program.Codes.OfType<LinearMove>().Count()));
+        var before = plate.Parts.Select(p => NestWriter.GetProgramText(p.Program)).ToArray();
+        var expected = new List<RapidEnumerator.Segment>();
+        var position = Vector.Zero;
+        foreach (var part in plate.Parts)
+        {
+            Assert.Equal(Mode.Absolute, part.Program.Mode);
+            foreach (var motion in part.Program.Codes.Cast<Motion>())
+            {
+                var destination = part.Location + motion.EndPoint;
+                if (motion is RapidMove)
+                    expected.Add(new RapidEnumerator.Segment(position, destination));
+                position = destination;
+            }
+        }
+
+        var actual = RapidEnumerator.Enumerate(plate.Parts);
+
+        Assert.Equal(expected, actual);
+        Assert.Equal(before, plate.Parts.Select(p => NestWriter.GetProgramText(p.Program)));
+        plate.RegenerateCutOffs(settings);
+        Assert.Equal(expected, RapidEnumerator.Enumerate(plate.Parts));
+    }
+
+    [Theory]
+    [InlineData(Mode.Absolute, false)]
+    [InlineData(Mode.Incremental, false)]
+    [InlineData(Mode.Absolute, true)]
+    [InlineData(Mode.Incremental, true)]
+    public void Enumerate_OpenProgram_AdvancesPastLastPierce(Mode mode, bool endWithArc)
+    {
+        var program = new Program();
+        program.Codes.Add(new RapidMove(2, 3));
+        program.Codes.Add(new LinearMove(7, 3));
+        if (endWithArc)
+            program.Codes.Add(new ArcMove(8, 4, 7, 4));
+        program.Mode = mode;
+        var first = new Part(new Drawing("open path", program), new Vector(100, 200));
+        var next = NextPart();
+        var before = NestWriter.GetProgramText(first.Program);
+
+        var segments = RapidEnumerator.Enumerate(new[] { first, next });
+
+        Assert.Equal(2, segments.Count);
+        Assert.Equal(new Vector(102, 203), segments[0].To);
+        Assert.Equal(endWithArc ? new Vector(108, 204) : new Vector(107, 203), segments[1].From);
+        Assert.Equal(new Vector(12, 23), segments[1].To);
+        Assert.Equal(before, NestWriter.GetProgramText(first.Program));
+    }
+
+    [Fact]
+    public void Enumerate_FinalSubprogram_UsesItsCutEndpointForNextPart()
+    {
+        var hole = new Program(Mode.Incremental);
+        hole.Codes.Add(new RapidMove(0.5, 0));
+        hole.Codes.Add(new LinearMove(0, 0.1));
+        var program = new Program();
+        program.Codes.Add(new RapidMove(1, 0));
+        program.Codes.Add(new LinearMove(2, 0));
+        program.Codes.Add(new SubProgramCall { Id = 1, Program = hole, Offset = new Vector(2, 2) });
+        var first = new Part(new Drawing("hole last", program), new Vector(100, 200));
+
+        var segments = RapidEnumerator.Enumerate(new[] { first, NextPart() });
+
+        Assert.Equal(3, segments.Count);
+        Assert.Equal(new Vector(102, 200), segments[1].From);
+        Assert.Equal(new Vector(102.5, 202), segments[1].To);
+        Assert.Equal(new Vector(102.5, 202.1), segments[2].From);
+        Assert.Equal(new Vector(12, 23), segments[2].To);
+    }
+
+    [Fact]
+    public void Enumerate_TrailingRapid_RemainsTheNextPartsStartPosition()
+    {
+        var program = new Program();
+        program.Codes.Add(new RapidMove(1, 0));
+        program.Codes.Add(new LinearMove(2, 0));
+        program.Codes.Add(new RapidMove(3, 4));
+        var first = new Part(new Drawing("park after cut", program), new Vector(100, 200));
+
+        var segments = RapidEnumerator.Enumerate(new[] { first, NextPart() });
+
+        Assert.Equal(3, segments.Count);
+        Assert.Equal(new Vector(102, 200), segments[1].From);
+        Assert.Equal(new Vector(103, 204), segments[1].To);
+        Assert.Equal(new Vector(103, 204), segments[2].From);
+    }
+
+    [Fact]
+    public void Enumerate_EmptyPlate_HasNoRapids()
+    {
+        Assert.Empty(RapidEnumerator.Enumerate(Array.Empty<Part>()));
+    }
+
+    private static Part NextPart()
+    {
+        var program = new Program();
+        program.Codes.Add(new RapidMove(2, 3));
+        program.Codes.Add(new LinearMove(4, 3));
+        return new Part(new Drawing("next", program), new Vector(10, 20));
+    }
+}

OpenNest.Tests/CNC/ProgramSubProgramTransformTests.cs

@@ -0,0 +1,111 @@
+using OpenNest.CNC;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+
+namespace OpenNest.Tests.CNC;
+
+/// <summary>
+/// Hole sub-programs are shared by reference: identical holes call one sub-program,
+/// and program copies must not reach back into the source's sub-programs.
+/// </summary>
+public class ProgramSubProgramTransformTests
+{
+    private const double QuarterTurn = System.Math.PI / 2;
+
+    /// <summary>Incremental hole sub-program: a lead-in from the hole centre to
+    /// (1, 0), then a full radius-1 circle.</summary>
+    private static Program MakeHoleSub()
+    {
+        var sub = new Program(Mode.Absolute);
+        sub.Codes.Add(new LinearMove(new Vector(1, 0)) { Layer = LayerType.Leadin });
+        sub.Codes.Add(new ArcMove(new Vector(1, 0), new Vector(0, 0), RotationType.CW));
+        sub.Mode = Mode.Incremental;
+        return sub;
+    }
+
+    /// <summary>Program with two identical holes, at (5, 5) and (15, 5), calling one
+    /// shared sub-program, as <c>ContourCuttingStrategy</c> emits them.</summary>
+    private static Program MakeTwoHoleProgram()
+    {
+        var sub = MakeHoleSub();
+        var pgm = new Program(Mode.Absolute);
+        pgm.SubPrograms[7] = sub;
+        pgm.Codes.Add(new SubProgramCall { Id = 7, Program = sub, Offset = new Vector(5, 5) });
+        pgm.Codes.Add(new SubProgramCall { Id = 7, Program = sub, Offset = new Vector(15, 5) });
+        return pgm;
+    }
+
+    /// <summary>End points of the lead-in lines in the program's own frame.</summary>
+    private static List<Vector> LeadInEnds(Program pgm) =>
+        ConvertProgram
+            .ToGeometry(pgm)
+            .OfType<Line>()
+            .Where(l => l.Layer == SpecialLayers.Leadin)
+            .Select(l => l.EndPoint)
+            .ToList();
+
+    private static void AssertPoint(double x, double y, Vector actual)
+    {
+        Assert.Equal(x, actual.X, 6);
+        Assert.Equal(y, actual.Y, 6);
+    }
+
+    [Fact]
+    public void Rotate_SharedSubProgram_TurnsEachHoleOnce()
+    {
+        var pgm = MakeTwoHoleProgram();
+
+        pgm.Rotate(QuarterTurn);
+
+        // (5, 5) -> (-5, 5) and (15, 5) -> (-5, 15); each lead-in ends one unit along
+        // the rotated +X axis, i.e. at +Y from its centre.
+        var ends = LeadInEnds(pgm);
+        Assert.Equal(2, ends.Count);
+        AssertPoint(-5, 6, ends[0]);
+        AssertPoint(-5, 16, ends[1]);
+    }
+
+    [Fact]
+    public void Clone_DoesNotRealignSourceSubProgram()
+    {
+        var pgm = MakeTwoHoleProgram();
+        pgm.Rotate(QuarterTurn);
+        var before = LeadInEnds(pgm);
+
+        _ = pgm.Clone();
+
+        var after = LeadInEnds(pgm);
+        AssertPoint(before[0].X, before[0].Y, after[0]);
+        AssertPoint(before[1].X, before[1].Y, after[1]);
+    }
+
+    [Fact]
+    public void Clone_OwnsItsSubPrograms()
+    {
+        var pgm = MakeTwoHoleProgram();
+
+        var copy = (Program)pgm.Clone();
+        copy.Rotate(QuarterTurn);
+
+        var sourceEnds = LeadInEnds(pgm);
+        AssertPoint(6, 5, sourceEnds[0]);
+        AssertPoint(16, 5, sourceEnds[1]);
+
+        var copyEnds = LeadInEnds(copy);
+        AssertPoint(-5, 6, copyEnds[0]);
+        AssertPoint(-5, 16, copyEnds[1]);
+    }
+
+    [Fact]
+    public void Clone_KeepsCallsAndDictionaryOnOneSharedCopy()
+    {
+        var pgm = MakeTwoHoleProgram();
+
+        var copy = (Program)pgm.Clone();
+
+        var calls = copy.Codes.OfType<SubProgramCall>().ToList();
+        Assert.NotSame(pgm.SubPrograms[7], copy.SubPrograms[7]);
+        Assert.Same(copy.SubPrograms[7], calls[0].Program);
+        Assert.Same(copy.SubPrograms[7], calls[1].Program);
+    }
+}

OpenNest.Tests/CNC/RapidEnumeratorTests.cs

@@ -54,6 +54,28 @@ namespace OpenNest.Tests.CNC
             Assert.Equal(new Vector(106, 206), segments[1].To);
         }
 
+        [Fact]
+        public void Enumerate_IncrementalProgramWithNonZeroFirstRapid_DoesNotDoubleCountIt()
+        {
+            // Lead-in programs (ContourCuttingStrategy output) are Incremental and
+            // start with a nonzero rapid from the part origin to the first pierce.
+            var pgm = new Program(Mode.Incremental);
+            pgm.Codes.Add(new RapidMove(2, 3));
+            pgm.Codes.Add(new LinearMove(5, 0));
+            pgm.Codes.Add(new RapidMove(1, 1));
+
+            var segments = RapidEnumerator.Enumerate(
+                pgm,
+                basePos: new Vector(100, 200),
+                startPos: new Vector(0, 0)
+            );
+
+            Assert.Equal(2, segments.Count);
+            Assert.Equal(new Vector(102, 203), segments[0].To);
+            Assert.Equal(new Vector(107, 203), segments[1].From);
+            Assert.Equal(new Vector(108, 204), segments[1].To);
+        }
+
         [Fact]
         public void Enumerate_SubProgramCall_RapidEndsAtAbsoluteHolePierce()
         {

OpenNest.Tests/CincinnatiCIFiber/CIFiberPostProcessorTests.cs

@@ -222,6 +222,58 @@ public class CIFiberPostProcessorTests
         Assert.Contains("13.2.4.1", ex.Message);
     }
 
+    [Fact]
+    public void Post_CutOff_PostsWithoutCompensationOrLeadIn()
+    {
+        var nest = MakeSquareWithHoleNest();
+        var plate = nest.Plates[0];
+
+        // Vertical cut-off at X=20: a bare rapid + line, no lead-in.
+        var cutOff = new CutOff(new Vector(20, 0), CutOffAxis.Vertical);
+        cutOff.Regenerate(plate, new CutOffSettings());
+        plate.Parts.Add(new Part(cutOff.Drawing, Vector.Zero));
+
+        var lines = Lines(Post(nest));
+
+        var n3 = lines.IndexOf("N3:");
+        Assert.True(n3 > lines.IndexOf("( PART:CutOff-V-20.00 )"));
+        Assert.Equal("/L \"L0\"", lines[n3 + 1]);
+        Assert.Equal("V.E.R3=3", lines[n3 + 2]);
+        Assert.StartsWith("G0X20Y", lines[n3 + 3]);
+        Assert.Equal("/L \"L4\"", lines[n3 + 4]);
+        Assert.Equal("/L \"L6\"", lines[n3 + 5]);
+        Assert.StartsWith("G1X20Y", lines[n3 + 6]);
+        Assert.Equal("/L \"ZHSOFF\"", lines[n3 + 7]);
+    }
+
+    [Fact]
+    public void Post_CutOff_FollowsPlateSequence()
+    {
+        // Plate order is the cut sequence: part, cut-off, part. The cut-off is
+        // sequence 2, so it posts second, not after every part.
+        var nest = MakeSquareWithHoleNest();
+        var plate = nest.Plates[0];
+        plate.Parts.Add(new Part(plate.Parts[0].BaseDrawing, new Vector(40, 2)));
+
+        var cutOff = new CutOff(new Vector(20, 0), CutOffAxis.Vertical);
+        cutOff.Regenerate(plate, new CutOffSettings());
+        plate.Parts.Insert(1, new Part(cutOff.Drawing, Vector.Zero));
+
+        var lines = Lines(Post(nest));
+
+        Assert.Equal(
+            new[] { "( PART:square-hole )", "( PART:CutOff-V-20.00 )", "( PART:square-hole )" },
+            lines.Where(l => l.StartsWith("( PART:")).ToArray()
+        );
+
+        // Part number and restart label run in the same order: the first
+        // part's hole and perimeter are N1/N2, so the cut-off is N3.
+        var cutOffBlock = lines.IndexOf("( PART:CutOff-V-20.00 )");
+        Assert.Equal("( Part #2 )", lines[cutOffBlock - 1]);
+        Assert.Equal("V.E.R4=2", lines[cutOffBlock + 1]);
+        Assert.Equal("N3:", lines[cutOffBlock + 2]);
+    }
+
     [Fact]
     public void Post_ValidatesTableSize()
     {
@@ -280,4 +332,240 @@ public class CIFiberPostProcessorTests
         Assert.Contains("G0X50Y50", output);
         Assert.Contains("V.E.R3=1", output);
     }
+
+    [Fact]
+    public void MaterialCodes_MatchIgnoringCase_AfterJsonReload()
+    {
+        var options = new System.Text.Json.JsonSerializerOptions();
+        var json = System.Text.Json.JsonSerializer.Serialize(
+            new CIFiberPostConfig
+            {
+                MaterialCodes = new() { ["Stainless"] = "SSN" },
+                DefaultMaterialCode = "MSN",
+            },
+            options
+        );
+
+        var config = System.Text.Json.JsonSerializer.Deserialize<CIFiberPostConfig>(json, options)!;
+
+        Assert.Equal("SSN", config.ResolveMaterialCode("stainless"));
+        Assert.Equal("SSN", config.ResolveMaterialCode(" STAINLESS "));
+        Assert.Equal("MSN", config.ResolveMaterialCode("Aluminum"));
+    }
+
+    [Fact]
+    public void SavedConfigWithRetiredPartComment_StillLoads()
+    {
+        const string json = """
+            { "PartComment": "OLD", "MaxTableX": 120.0, "DefaultMaterialCode": "SSN" }
+            """;
+
+        var config = System.Text.Json.JsonSerializer.Deserialize<CIFiberPostConfig>(json)!;
+
+        Assert.Equal(120.0, config.MaxTableX);
+        Assert.Equal("SSN", config.DefaultMaterialCode);
+    }
+
+    private static Nest MakeMultiSheetNest(params (double Width, double Length)[] extraSheets)
+    {
+        var nest = MakeSquareWithHoleNest();
+        var drawing = nest.Plates[0].Parts[0].BaseDrawing;
+        foreach (var (width, length) in extraSheets)
+        {
+            var plate = new Plate(width, length);
+            plate.Parts.Add(new Part(drawing, new Vector(3, 4)));
+            nest.Plates.Add(plate);
+        }
+        return nest;
+    }
+
+    private static string NewTempDir()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), $"cifiber-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dir);
+        return dir;
+    }
+
+    [Fact]
+    public void Post_OneProgramPerSheet_WritesNumberedFiles_EachAFullProgram()
+    {
+        var nest = MakeMultiSheetNest((48, 96));
+        nest.Plates.Add(new Plate(60, 120)); // empty sheet: not posted
+        var dir = NewTempDir();
+        try
+        {
+            var chosen = Path.Combine(dir, "JOB.cnc");
+            var post = new CIFiberPostProcessor(MakeConfig());
+
+            var expected = post.GetOutputFiles(nest, chosen);
+            post.Post(nest, chosen);
+
+            Assert.Equal(
+                new[] { Path.Combine(dir, "JOB-1.cnc"), Path.Combine(dir, "JOB-2.cnc") },
+                expected
+            );
+            Assert.Equal(
+                expected.OrderBy(f => f),
+                Directory.GetFiles(dir).OrderBy(f => f)
+            );
+
+            var first = Lines(File.ReadAllText(expected[0]));
+            var second = Lines(File.ReadAllText(expected[1]));
+
+            Assert.Contains("V.E.X_SIZE = 120.000", first);
+            Assert.Contains("V.E.X_SIZE = 96.000", second);
+            Assert.Contains("V.E.Y_SIZE = 48.000", second);
+            Assert.Contains("( Sheet number - 1 )", first);
+            Assert.Contains("( Sheet number - 2 )", second);
+
+            foreach (var program in new[] { first, second })
+            {
+                // Restart labels start over in every program.
+                Assert.Contains("N1:", program);
+                Assert.DoesNotContain("N3:", program);
+                Assert.Single(program, "M50");
+                Assert.Equal(
+                    new[] { "L PROGRAMEND.NC", "M50", "M30", "%", "" },
+                    program.TakeLast(5)
+                );
+            }
+            Assert.Contains("G0X3Y3.5", second); // hole pierce at the sheet-2 part location
+        }
+        finally
+        {
+            Directory.Delete(dir, true);
+        }
+    }
+
+    [Fact]
+    public void Post_SingleProgram_ChangesPalletBetweenSheets()
+    {
+        var nest = MakeMultiSheetNest((60, 120), (60, 120));
+        var config = MakeConfig();
+        config.OneProgramPerSheet = false;
+        var dir = NewTempDir();
+        try
+        {
+            var chosen = Path.Combine(dir, "JOB.cnc");
+            var post = new CIFiberPostProcessor(config);
+
+            Assert.Equal(new[] { chosen }, post.GetOutputFiles(nest, chosen));
+            post.Post(nest, chosen);
+            Assert.Equal(new[] { chosen }, Directory.GetFiles(dir));
+
+            var lines = Lines(File.ReadAllText(chosen));
+            Assert.Equal(3, lines.Count(l => l == "M50"));
+            Assert.Single(lines, "M30");
+
+            var sheet2 = lines.IndexOf("( Sheet number - 2 )");
+            Assert.Equal(
+                new[] { "( PART END )", "/L \"L0\"", "M50", "( Sheet number - 2 )" },
+                lines.Skip(sheet2 - 3).Take(4)
+            );
+            Assert.True(lines.IndexOf("( Sheet number - 3 )") > sheet2);
+
+            // Restart labels continue across sheets within one program.
+            Assert.Contains("N6:", lines);
+            Assert.Contains("V.E.R3=6", lines);
+        }
+        finally
+        {
+            Directory.Delete(dir, true);
+        }
+    }
+
+    [Fact]
+    public void Post_SingleProgram_RejectsMixedSheetSizes_WritingNothing()
+    {
+        var nest = MakeMultiSheetNest((48, 96));
+        var config = MakeConfig();
+        config.OneProgramPerSheet = false;
+        var dir = NewTempDir();
+        try
+        {
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+                new CIFiberPostProcessor(config).Post(nest, Path.Combine(dir, "JOB.cnc"))
+            );
+            Assert.Contains("One program per sheet", ex.Message);
+            Assert.Empty(Directory.GetFiles(dir));
+        }
+        finally
+        {
+            Directory.Delete(dir, true);
+        }
+    }
+
+    [Fact]
+    public void Post_OneProgramPerSheet_OversizeSheet_WritesNoFiles()
+    {
+        var nest = MakeMultiSheetNest((60, 200)); // second sheet 200 long > 160.25 table
+        var dir = NewTempDir();
+        try
+        {
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+                new CIFiberPostProcessor(MakeConfig()).Post(nest, Path.Combine(dir, "JOB.cnc"))
+            );
+            Assert.Contains("exceeds maximum table X", ex.Message);
+            Assert.Empty(Directory.GetFiles(dir));
+        }
+        finally
+        {
+            Directory.Delete(dir, true);
+        }
+    }
+
+    [Fact]
+    public void Post_OneProgramPerSheet_SingleSheet_UsesChosenName()
+    {
+        var nest = MakeSquareWithHoleNest();
+        var dir = NewTempDir();
+        try
+        {
+            var chosen = Path.Combine(dir, "JOB.cnc");
+            var post = new CIFiberPostProcessor(MakeConfig());
+
+            Assert.Equal(new[] { chosen }, post.GetOutputFiles(nest, chosen));
+            post.Post(nest, chosen);
+
+            Assert.Equal(Post(nest), File.ReadAllText(chosen));
+        }
+        finally
+        {
+            Directory.Delete(dir, true);
+        }
+    }
+
+    [Fact]
+    public void Post_PalletChangeCode_IsConfigurable()
+    {
+        var custom = MakeConfig();
+        custom.PalletChangeCode = " M51 ";
+        var lines = Lines(Post(MakeSquareWithHoleNest(), custom));
+        Assert.Equal(new[] { "L PROGRAMEND.NC", "M51", "M30", "%", "" }, lines.TakeLast(5));
+        Assert.DoesNotContain("M50", lines);
+
+        var none = MakeConfig();
+        none.PalletChangeCode = "";
+        lines = Lines(Post(MakeSquareWithHoleNest(), none));
+        Assert.Equal(new[] { "L PROGRAMEND.NC", "M30", "%", "" }, lines.TakeLast(4));
+    }
+
+    [Fact]
+    public void PostToStream_MultiSheetPerSheetMode_Throws()
+    {
+        var nest = MakeMultiSheetNest((60, 120));
+        var ex = Assert.Throws<InvalidOperationException>(() => Post(nest));
+        Assert.Contains("file path", ex.Message);
+    }
+
+    [Fact]
+    public void SavedConfigWithoutSheetSettings_DefaultsToPerSheetAndM50()
+    {
+        var config = System.Text.Json.JsonSerializer.Deserialize<CIFiberPostConfig>(
+            """{ "MaxTableX": 120.0 }"""
+        )!;
+
+        Assert.True(config.OneProgramPerSheet);
+        Assert.Equal("M50", config.PalletChangeCode);
+    }
 }