Merge remote-tracking branch 'origin/master'

Task 6 of the whole-job engine API: adapt the public NestRequest/NestRunner/
NestResponse surface to delegate to the whole-job runner instead of a manual
quantity loop.

- NestRequest: optional explicit Plates stock list (null keeps the legacy
  unlimited SheetSize fallback; empty list means no available stock),
  optional per-part Id (derived as part-{index} when absent), and an explicit
  PlacementStrategy that takes precedence over the legacy Strategy.
- NestRequestPlate: one physical-stock type (id, size, quantity, spacing,
  quadrant).
- NestRunner: imports each DXF once, propagates priority/rotation constraints,
  runs a single NestJobRunner solve, materializes ID/pose placements exactly
  once, and reports aggregate utilization as total placed part area over total
  physical sheet area.
- NestResponse: exposes status, stop reason, part fulfillment, stock usage,
  and plate-to-stock mapping; .nestquote save/load gains a schema version and
  reports completion as unknown for old archives lacking fulfillment metadata.
- Tests: extend the Api request/runner/persistence suites for legacy SheetSize,
  explicit mixed finite stock, stock exhaustion, weighted utilization, old
  archive loading, and new-archive round trips.

Verification: cross-compiles clean on net8.0-windows (Linux). The Api tests
require a Windows runner (net8.0-windows) and are NOT executed here; the
delegated engine logic is covered by the 70-test net8.0 Engine.Tests suite
(committed in Task 5). Windows runtime verification remains outstanding.

.gitignore

@@ -213,3 +213,6 @@ docs/superpowers/
 
 # Launch settings
 **/Properties/launchSettings.json
+
+# Local test config (contains user-specific paths to proprietary test assets)
+OpenNest.Tests/test-config.json

CLAUDE.md

@@ -14,11 +14,13 @@ This is a .NET 8 solution using SDK-style `.csproj` files targeting `net8.0-wind
 dotnet build OpenNest.sln
 ```
 
+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 existing `OpenNest.Tests` suite targets `net8.0-windows` and requires a Windows runner; cross-compiling on Linux is not Windows runtime verification.
+
 NuGet dependencies: `ACadSharp` 3.1.32 (DXF/DWG import/export, in OpenNest.IO), `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).
 
 ## Architecture
 
-Eight projects form a layered architecture:
+Nine projects form a layered architecture:
 
 ### OpenNest.Core (class library)
 Domain model, geometry, and CNC primitives organized into namespaces:
@@ -35,9 +37,11 @@ Domain model, geometry, and CNC primitives organized into namespaces:
 - **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 with a pluggable engine architecture. `NestEngineBase` is the abstract base class; `DefaultNestEngine` (formerly `NestEngine`) provides the multi-phase fill strategy. `NestEngineRegistry` manages available engines (built-in + plugins from `Engines/` directory) and the globally active engine.
+Nesting algorithms provide both a legacy single-plate API and a whole-job API. The legacy path centers on `NestEngineBase`, `DefaultNestEngine` (formerly `NestEngine`), and the global `NestEngineRegistry`. New job callers use immutable, ID-based contracts in `Jobs/`: `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 strategy without reading or changing the process-global registry.
 
-- **Engine hierarchy**: `NestEngineBase` (abstract) → `DefaultNestEngine` (Linear, Pairs, RectBestFit, Remainder phases) → `VerticalRemnantEngine` (optimizes for right-side drop), `HorizontalRemnantEngine` (optimizes for top-side drop). Custom engines subclass `NestEngineBase` and register via `NestEngineRegistry.Register()` or as plugin DLLs in `Engines/`.
+- **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` and `StripPlateNester` are migrated built-ins with run-scoped private geometry; `LegacyPlateNesterAdapter` remains for remnant strategies and legacy plugins/callers during rollout. Job-path identity is reference-based rather than drawing name; `PlateOptimizer` and NFP/`AutoNester` retain legacy name-based helpers and are deliberately outside the runner path.
+- **Engine hierarchy**: `NestEngineBase` (abstract) → `DefaultNestEngine` (Linear, Pairs, RectBestFit, Remainder phases) → `VerticalRemnantEngine` (optimizes for right-side drop), `HorizontalRemnantEngine` (optimizes for top-side drop). Custom engines subclass `NestEngineBase` and register via `NestEngineRegistry.Register()` or as plugin DLLs in `Engines/`. Existing desktop, CLI, and MCP callers remain on this compatibility path until separate migrations preserve their existing-plate, preview, and accept/cancel semantics.
 - **IFillComparer**: Interface enabling engine-specific scoring. `DefaultFillComparer` (count-then-density), `VerticalRemnantComparer` (minimize X-extent), `HorizontalRemnantComparer` (minimize Y-extent). Engines provide their comparer via `CreateComparer()` factory, grouped into `FillPolicy` on `FillContext`.
 - **NestEngineRegistry**: Static registry — `Create(Plate)` factory, `ActiveEngineName` global selection, `LoadPlugins(directory)` for DLL discovery. All callsites use `NestEngineRegistry.Create(plate)` except `BruteForceRunner` which uses `new DefaultNestEngine(plate)` directly for training consistency.
 - **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`.
@@ -69,6 +73,15 @@ GPU-accelerated pair evaluation for best-fit nesting. `GpuPairEvaluator` impleme
 ### 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 `NestEngineBase` implementations against each other on real `.nest` files. 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.
+- `BenchmarkRunner` gives each (job, engine) pair a fresh `Plate`/`NestItem` list (`BenchmarkJob.CreatePlate()`/`CreateItems()`) so engines can't see each other's mutated state, then calls the engine's `Nest()` and times it.
+- `NestValidator` checks the returned layout: every part inside `Plate.WorkArea()`, every pair at least `Plate.PartSpacing` apart (checked geometrically via each part's own world-space polygon, inflated by the spacing — works on arbitrary concave/holed shapes, not just bounding boxes), and no drawing over its requested quantity. An invalid or throwing run scores zero for that job.
+- Scoring matches `Plate.Utilization()` (placed drawing area / full sheet area, `Plate.Area()`). If an engine placed every requested part, ties are broken by the smaller used-bounding-box (`Report`'s ranking rule) — a more compact layout leaves a bigger usable remnant.
+- `--engines Name1,Name2` filters to specific registered engines (default: all); `--csv <path>` writes a flat per-job CSV alongside the console report.
+
 ### 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/`.
 

OpenNest.Api/NestRequest.cs

@@ -6,10 +6,18 @@ namespace OpenNest.Api;
 public class NestRequest
 {
     public IReadOnlyList<NestRequestPart> Parts { get; init; } = [];
+    /// <summary>
+    /// Explicit available physical stock. Null keeps the legacy unlimited SheetSize fallback;
+    /// an empty list deliberately means no stock is available.
+    /// </summary>
+    public IReadOnlyList<NestRequestPlate> Plates { get; init; }
     public Size SheetSize { get; init; } = new(60, 120);
+    /// <summary>Built-in whole-job placement strategy. Explicit values take precedence over legacy Strategy.</summary>
+    public string PlacementStrategy { get; init; } = "Default";
     public string Material { get; init; } = "Steel, A1011 HR";
     public double Thickness { get; init; } = 0.06;
     public double Spacing { get; init; } = 0.1;
+    /// <summary>Legacy compatibility setting; Auto maps to the Default whole-job strategy.</summary>
     public NestStrategy Strategy { get; init; } = NestStrategy.Auto;
     public CutParameters Cutting { get; init; } = CutParameters.Default;
 }

OpenNest.Api/NestRequestPart.cs

@@ -2,6 +2,8 @@ namespace OpenNest.Api;
 
 public class NestRequestPart
 {
+    /// <summary>Optional stable requirement identity. NestRunner derives part-{requestIndex} when omitted.</summary>
+    public string Id { get; init; }
     public string DxfPath { get; init; }
     public int Quantity { get; init; } = 1;
     public bool AllowRotation { get; init; } = true;

OpenNest.Api/NestRequestPlate.cs

@@ -0,0 +1,15 @@
+using OpenNest.Geometry;
+
+namespace OpenNest.Api;
+
+/// <summary>One explicit physical-stock type for a whole nesting job.</summary>
+public class NestRequestPlate
+{
+    public string Id { get; init; }
+    public Size Size { get; init; }
+    /// <summary>Available physical sheets; null means unlimited.</summary>
+    public int? Quantity { get; init; }
+    public double PartSpacing { get; init; }
+    public Spacing EdgeSpacing { get; init; }
+    public int Quadrant { get; init; } = 1;
+}

OpenNest.Api/NestResponse.cs

@@ -1,18 +1,40 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using OpenNest.IO;
 
 namespace OpenNest.Api;
 
+/// <summary>Stable fulfillment metadata for one requested part identity.</summary>
+public sealed record NestPartFulfillment(string PartId, int Requested, int Placed, int Unplaced);
+
+/// <summary>Physical-sheet usage for one stock identity.</summary>
+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);
+
 public class NestResponse
 {
+    public const int CurrentSchemaVersion = 2;
+
+    /// <summary>Zero identifies an archive written before response metadata was versioned.</summary>
+    public int SchemaVersion { get; init; } = CurrentSchemaVersion;
     public int SheetCount { get; init; }
+    /// <summary>Placed-part area divided by total materialized physical-sheet area, as a 0.0–1.0 ratio.</summary>
     public double Utilization { get; init; }
     public TimeSpan CutTime { get; init; }
     public TimeSpan Elapsed { get; init; }
+    /// <summary>Null means an older archive did not record whole-job fulfillment status.</summary>
+    public NestJobStatus? Status { get; init; }
+    public NestJobStopReason? StopReason { get; init; }
+    public IReadOnlyList<NestPartFulfillment> Fulfillment { get; init; } = [];
+    public IReadOnlyList<NestStockUsage> StockUsage { get; init; } = [];
+    public IReadOnlyList<NestPlateStockMapping> PlateStockMappings { get; init; } = [];
     public Nest Nest { get; init; }
     public NestRequest Request { get; init; }
 
@@ -20,7 +42,8 @@ public class NestResponse
     {
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
         WriteIndented = true,
-        IncludeFields = true  // Required for OpenNest.Geometry.Size (public fields)
+        IncludeFields = true, // Required for OpenNest.Geometry.Size and Spacing public fields.
+        Converters = { new JsonStringEnumConverter() }
     };
 
     public async Task SaveAsync(string path)
@@ -28,32 +51,34 @@ public class NestResponse
         using var fs = new FileStream(path, FileMode.Create);
         using var zip = new ZipArchive(fs, ZipArchiveMode.Create);
 
-        // Write request.json
         var requestEntry = zip.CreateEntry("request.json");
         await using (var stream = requestEntry.Open())
         {
             await JsonSerializer.SerializeAsync(stream, Request, JsonOptions);
         }
 
-        // Write response.json (metrics only)
-        var metrics = new
-        {
-            SheetCount,
-            Utilization,
-            CutTimeTicks = CutTime.Ticks,
-            ElapsedTicks = Elapsed.Ticks
-        };
+        // Keep persisted data versioned and detached from the live mutable Nest graph.
         var responseEntry = zip.CreateEntry("response.json");
         await using (var stream = responseEntry.Open())
         {
-            await JsonSerializer.SerializeAsync(stream, metrics, JsonOptions);
+            await JsonSerializer.SerializeAsync(stream, new NestResponseArchiveDto
+            {
+                SchemaVersion = CurrentSchemaVersion,
+                SheetCount = SheetCount,
+                Utilization = Utilization,
+                CutTimeTicks = CutTime.Ticks,
+                ElapsedTicks = Elapsed.Ticks,
+                Status = Status,
+                StopReason = StopReason,
+                Fulfillment = Fulfillment is null ? [] : new List<NestPartFulfillment>(Fulfillment),
+                StockUsage = StockUsage is null ? [] : new List<NestStockUsage>(StockUsage),
+                PlateStockMappings = PlateStockMappings is null ? [] : new List<NestPlateStockMapping>(PlateStockMappings)
+            }, JsonOptions);
         }
 
-        // Write embedded nest.nest via NestWriter → MemoryStream → ZIP entry
         var nestEntry = zip.CreateEntry("nest.nest");
         using var nestMs = new MemoryStream();
-        var writer = new NestWriter(Nest);
-        writer.Write(nestMs);
+        new NestWriter(Nest).Write(nestMs);
         nestMs.Position = 0;
         await using (var stream = nestEntry.Open())
         {
@@ -66,25 +91,34 @@ public class NestResponse
         using var fs = new FileStream(path, FileMode.Open, FileAccess.Read);
         using var zip = new ZipArchive(fs, ZipArchiveMode.Read);
 
-        // Read request.json
         var requestEntry = zip.GetEntry("request.json")
             ?? throw new InvalidOperationException("Missing request.json in .nestquote file");
         NestRequest request;
         await using (var stream = requestEntry.Open())
         {
-            request = await JsonSerializer.DeserializeAsync<NestRequest>(stream, JsonOptions);
+            request = await JsonSerializer.DeserializeAsync<NestRequest>(stream, JsonOptions)
+                ?? throw new InvalidOperationException("Invalid request.json in .nestquote file");
         }
 
-        // Read response.json
         var responseEntry = zip.GetEntry("response.json")
             ?? throw new InvalidOperationException("Missing response.json in .nestquote file");
-        JsonElement metricsJson;
+        NestResponseArchiveDto archive;
+        var hasSchemaVersion = false;
+        var hasStatusMetadata = false;
         await using (var stream = responseEntry.Open())
+        using (var document = await JsonDocument.ParseAsync(stream))
         {
-            metricsJson = await JsonSerializer.DeserializeAsync<JsonElement>(stream, JsonOptions);
+            var root = document.RootElement;
+            hasSchemaVersion = root.TryGetProperty("schemaVersion", out _);
+            hasStatusMetadata = root.TryGetProperty("status", out _) ||
+                root.TryGetProperty("stopReason", out _) ||
+                root.TryGetProperty("fulfillment", out _) ||
+                root.TryGetProperty("stockUsage", out _) ||
+                root.TryGetProperty("plateStockMappings", out _);
+            archive = root.Deserialize<NestResponseArchiveDto>(JsonOptions)
+                ?? throw new InvalidOperationException("Invalid response.json in .nestquote file");
         }
 
-        // Read embedded nest.nest via NestReader(Stream)
         var nestEntry = zip.GetEntry("nest.nest")
             ?? throw new InvalidOperationException("Missing nest.nest in .nestquote file");
         Nest nest;
@@ -95,18 +129,37 @@ public class NestResponse
                 await stream.CopyToAsync(nestMs);
             }
             nestMs.Position = 0;
-            var reader = new NestReader(nestMs);
-            nest = reader.Read();
+            nest = new NestReader(nestMs).Read();
         }
 
         return new NestResponse
         {
-            SheetCount = metricsJson.GetProperty("sheetCount").GetInt32(),
-            Utilization = metricsJson.GetProperty("utilization").GetDouble(),
-            CutTime = TimeSpan.FromTicks(metricsJson.GetProperty("cutTimeTicks").GetInt64()),
-            Elapsed = TimeSpan.FromTicks(metricsJson.GetProperty("elapsedTicks").GetInt64()),
+            SchemaVersion = hasSchemaVersion ? archive.SchemaVersion : 0,
+            SheetCount = archive.SheetCount,
+            Utilization = archive.Utilization,
+            CutTime = TimeSpan.FromTicks(archive.CutTimeTicks),
+            Elapsed = TimeSpan.FromTicks(archive.ElapsedTicks),
+            Status = hasStatusMetadata ? archive.Status : null,
+            StopReason = hasStatusMetadata ? archive.StopReason : null,
+            Fulfillment = hasStatusMetadata ? archive.Fulfillment ?? [] : [],
+            StockUsage = hasStatusMetadata ? archive.StockUsage ?? [] : [],
+            PlateStockMappings = hasStatusMetadata ? archive.PlateStockMappings ?? [] : [],
             Nest = nest,
             Request = request
         };
     }
+
+    private sealed class NestResponseArchiveDto
+    {
+        public int SchemaVersion { get; init; }
+        public int SheetCount { get; init; }
+        public double Utilization { get; init; }
+        public long CutTimeTicks { get; init; }
+        public long ElapsedTicks { get; init; }
+        public NestJobStatus? Status { get; init; }
+        public NestJobStopReason? StopReason { get; init; }
+        public List<NestPartFulfillment> Fulfillment { get; init; } = [];
+        public List<NestStockUsage> StockUsage { get; init; } = [];
+        public List<NestPlateStockMapping> PlateStockMappings { get; init; } = [];
+    }
 }

OpenNest.Api/NestRunner.cs

@@ -11,125 +11,167 @@ namespace OpenNest.Api;
 
 public static class NestRunner
 {
+    private const string LegacyStockId = "legacy-sheet";
+
     public static Task<NestResponse> RunAsync(
         NestRequest request,
         IProgress<NestProgress> progress = null,
         CancellationToken token = default)
     {
-        if (request.Parts.Count == 0)
+        ArgumentNullException.ThrowIfNull(request);
+        var requestParts = request.Parts ?? throw new ArgumentException("Request parts must not be null.", nameof(request));
+        if (requestParts.Count == 0)
             throw new ArgumentException("Request must contain at least one part.", nameof(request));
 
         var sw = Stopwatch.StartNew();
+        var parts = IdentifyParts(requestParts);
+        var importedByPath = new Dictionary<string, Drawing>(StringComparer.Ordinal);
+        var jobParts = new List<NestJobPart>(parts.Count);
 
-        // 1. Import DXFs → Drawings
-        var drawings = new List<Drawing>();
-        foreach (var part in request.Parts)
-        {
-            if (!File.Exists(part.DxfPath))
-                throw new FileNotFoundException($"DXF file not found: {part.DxfPath}", part.DxfPath);
-
-            Drawing drawing;
-            try
-            {
-                drawing = CadImporter.ImportDrawing(part.DxfPath,
-                    new CadImportOptions { Quantity = part.Quantity });
-            }
-            catch (System.Exception ex)
-            {
-                throw new InvalidOperationException(
-                    $"Failed to import DXF: {part.DxfPath}", ex);
-            }
-
-            if (drawing.Program == null || drawing.Program.Codes.Count == 0)
-                throw new InvalidOperationException($"Failed to import DXF: {part.DxfPath}");
-
-            drawings.Add(drawing);
-        }
-
-        // 2. Build NestItems
-        var items = new List<NestItem>();
-        for (var i = 0; i < request.Parts.Count; i++)
-        {
-            var part = request.Parts[i];
-            items.Add(new NestItem
-            {
-                Drawing = drawings[i],
-                Quantity = part.Quantity,
-                Priority = part.Priority,
-                StepAngle = part.AllowRotation ? 0 : OpenNest.Math.Angle.TwoPI,
-            });
-        }
-
-        // 3. Multi-plate loop
-        var nest = new Nest();
-        nest.Thickness = request.Thickness;
-        nest.Material = new Material(request.Material);
-        var remaining = items.Select(item => item.Quantity).ToList();
-
-        while (remaining.Any(q => q > 0))
+        foreach (var part in parts)
         {
             token.ThrowIfCancellationRequested();
+            if (!File.Exists(part.Request.DxfPath))
+                throw new FileNotFoundException($"DXF file not found: {part.Request.DxfPath}", part.Request.DxfPath);
 
-            var plate = new Plate(request.SheetSize)
+            if (!importedByPath.TryGetValue(part.Request.DxfPath, out var drawing))
             {
-                PartSpacing = request.Spacing,
-            };
-
-            // Build items for this pass with remaining quantities
-            var passItems = new List<NestItem>();
-            for (var i = 0; i < items.Count; i++)
-            {
-                if (remaining[i] <= 0) continue;
-                passItems.Add(new NestItem
+                try
                 {
-                    Drawing = items[i].Drawing,
-                    Quantity = remaining[i],
-                    Priority = items[i].Priority,
-                    StepAngle = items[i].StepAngle,
-                });
+                    drawing = CadImporter.ImportDrawing(part.Request.DxfPath,
+                        new CadImportOptions { Quantity = part.Request.Quantity });
+                }
+                catch (Exception exception)
+                {
+                    throw new InvalidOperationException($"Failed to import DXF: {part.Request.DxfPath}", exception);
+                }
+
+                if (drawing.Program == null || drawing.Program.Codes.Count == 0)
+                    throw new InvalidOperationException($"Failed to import DXF: {part.Request.DxfPath}");
+
+                importedByPath.Add(part.Request.DxfPath, drawing);
             }
 
-            // Run engine
-            var engine = NestEngineRegistry.Create(plate);
-            var parts = engine.Nest(passItems, progress, token);
-
-            if (parts.Count == 0)
-                break; // No progress — part doesn't fit on fresh sheet
-
-            // Add parts to plate and nest
-            foreach (var p in parts)
-                plate.Parts.Add(p);
-
-            nest.Plates.Add(plate);
-
-            // Deduct placed quantities
-            foreach (var p in parts)
-            {
-                var idx = drawings.IndexOf(p.BaseDrawing);
-                if (idx >= 0)
-                    remaining[idx]--;
-            }
+            ConfigureDrawingForRequirement(drawing, part.Request);
+            jobParts.Add(DrawingJobMapper.FromDrawing(part.Id, drawing, part.Request.Quantity));
         }
 
-        // 4. Compute timing
+        var job = new NestJob(jobParts, CreateStock(request),
+            new NestJobOptions(ResolvePlacementStrategy(request)));
+        var jobProgress = progress == null ? null : new JobProgressBridge(progress);
+        var result = new NestJobRunner(PlateNesterFactory.Create).Solve(job, jobProgress, token);
+
+        // This is the sole translation from immutable result poses to mutable legacy output objects.
+        var materialized = NestResultMaterializer.Materialize(job, result);
+        var nest = materialized.Nest;
+        nest.Thickness = request.Thickness;
+        nest.Material = new Material(request.Material);
+
         var timingInfo = Timing.GetTimingInfo(nest);
         var cutTime = Timing.CalculateTime(timingInfo, request.Cutting);
-
         sw.Stop();
 
-        // 5. Build response
-        var response = new NestResponse
+        return Task.FromResult(new NestResponse
         {
             SheetCount = nest.Plates.Count,
-            Utilization = nest.Plates.Count > 0
-                ? nest.Plates.Average(p => p.Utilization())
-                : 0,
+            Utilization = CalculateUtilization(nest),
             CutTime = cutTime,
             Elapsed = sw.Elapsed,
+            Status = result.Status,
+            StopReason = result.StopReason,
+            Fulfillment = result.Fulfillment
+                .Select(value => new NestPartFulfillment(value.PartId, value.Requested, value.Placed, value.Unplaced))
+                .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
-        };
+        });
+    }
 
-        return Task.FromResult(response);
+    private static IReadOnlyList<IdentifiedRequestPart> IdentifyParts(IReadOnlyList<NestRequestPart> requestParts)
+    {
+        var identified = new List<IdentifiedRequestPart>(requestParts.Count);
+        var ids = new HashSet<string>(StringComparer.Ordinal);
+        for (var index = 0; index < requestParts.Count; index++)
+        {
+            var part = requestParts[index] ?? throw new ArgumentException("Request parts must not contain null entries.", nameof(requestParts));
+            var id = part.Id ?? $"part-{index}";
+            if (string.IsNullOrWhiteSpace(id))
+                throw new ArgumentException("Part IDs must not be blank.", nameof(requestParts));
+            if (!ids.Add(id))
+                throw new ArgumentException("Part IDs must be unique.", nameof(requestParts));
+            identified.Add(new IdentifiedRequestPart(id, part));
+        }
+
+        return identified;
+    }
+
+    private static IReadOnlyList<NestPlateStock> CreateStock(NestRequest request)
+    {
+        if (request.Plates is null)
+        {
+            return
+            [
+                new NestPlateStock(LegacyStockId, request.SheetSize, quantity: null,
+                    partSpacing: request.Spacing)
+            ];
+        }
+
+        var stock = new List<NestPlateStock>(request.Plates.Count);
+        foreach (var plate in request.Plates)
+        {
+            if (plate is null)
+                throw new ArgumentException("Request plates must not contain null entries.", nameof(request));
+            stock.Add(new NestPlateStock(plate.Id, plate.Size, plate.Quantity, plate.PartSpacing,
+                plate.EdgeSpacing, plate.Quadrant));
+        }
+
+        return stock;
+    }
+
+    private static void ConfigureDrawingForRequirement(Drawing drawing, NestRequestPart part)
+    {
+        drawing.Priority = part.Priority;
+        drawing.Constraints ??= new NestConstraints();
+        if (!part.AllowRotation)
+        {
+            // A zero legacy step means automatic rotation to DrawingJobMapper, so lock it explicitly.
+            drawing.Constraints.StepAngle = OpenNest.Math.Angle.TwoPI;
+            drawing.Constraints.StartAngle = 0;
+            drawing.Constraints.EndAngle = 0;
+        }
+    }
+
+    private static string ResolvePlacementStrategy(NestRequest request) => request.PlacementStrategy ?? request.Strategy switch
+    {
+        NestStrategy.Auto => "Default",
+        _ => throw new NotSupportedException($"Unknown legacy nesting strategy: {request.Strategy}.")
+    };
+
+    private static double CalculateUtilization(Nest nest)
+    {
+        var sheetArea = nest.Plates.Sum(plate => plate.Area());
+        if (sheetArea == 0) return 0;
+        var placedArea = nest.Plates.Sum(plate => plate.Parts
+            .Where(part => !part.BaseDrawing.IsCutOff)
+            .Sum(part => part.BaseDrawing.Area));
+        return placedArea / sheetArea;
+    }
+
+    private sealed record IdentifiedRequestPart(string Id, NestRequestPart Request);
+
+    private sealed class JobProgressBridge(IProgress<NestProgress> progress) : IProgress<NestJobProgress>
+    {
+        public void Report(NestJobProgress value)
+        {
+            ArgumentNullException.ThrowIfNull(value);
+            if (value.LegacyProgress is not null)
+                progress.Report(value.LegacyProgress);
+        }
     }
 }

OpenNest.Benchmark/BenchmarkJob.cs

@@ -0,0 +1,90 @@
+using OpenNest.Geometry;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace OpenNest.Benchmark
+{
+    /// <summary>
+    /// One request to nest a specific drawing, with the quantity and rotation
+    /// constraints pulled from its source .nest file.
+    /// </summary>
+    public class DrawingRequest
+    {
+        public Drawing Drawing { get; init; }
+        public int Quantity { get; init; }
+        public int Priority { get; init; }
+        public double StepAngle { get; init; }
+        public double RotationStart { get; init; }
+        public double RotationEnd { get; init; }
+    }
+
+    /// <summary>
+    /// An immutable specification for one benchmark job: the full set of
+    /// drawings/quantities that must be nested, and the pool of sheet sizes the
+    /// engine may draw from while doing it. A single run may use several
+    /// plates - possibly of different sizes - to place everything, the same
+    /// way a real production job spreads across whatever plates it needs
+    /// rather than being handed one fixed-size sheet.
+    /// </summary>
+    public class BenchmarkJob
+    {
+        public string SourceFile { get; init; }
+        public List<Size> CandidateSizes { get; init; }
+        public Spacing EdgeSpacing { get; init; }
+        public double PartSpacing { get; init; }
+        public int Quadrant { get; init; }
+        public List<DrawingRequest> Requests { get; init; }
+
+        public string Name => Path.GetFileNameWithoutExtension(SourceFile);
+
+        public int TotalRequestedQuantity => Requests.Sum(r => r.Quantity);
+
+        /// <summary>
+        /// A blank plate carrying only the job's spacing/quadrant template.
+        /// MultiPlateNester.CreatePlate copies these settings onto whichever
+        /// size it ultimately picks; its Size is only the fallback used when
+        /// nothing in the candidate pool fits, so it's set to the largest
+        /// candidate rather than an arbitrary one.
+        /// </summary>
+        public Plate CreateTemplatePlate()
+        {
+            var fallbackSize = CandidateSizes
+                .OrderByDescending(s => s.Width * s.Length)
+                .FirstOrDefault();
+
+            return new Plate(fallbackSize)
+            {
+                EdgeSpacing = EdgeSpacing,
+                PartSpacing = PartSpacing,
+                Quadrant = Quadrant,
+            };
+        }
+
+        /// <summary>
+        /// The candidate sizes as PlateOptions for MultiPlateNester.CreatePlate.
+        /// Cost is area-proportional since no real per-size material pricing is
+        /// available here - this only affects which size is preferred when more
+        /// than one candidate fits, favoring the smaller/cheaper sheet.
+        /// </summary>
+        public List<PlateOption> BuildPlateOptions()
+        {
+            return CandidateSizes
+                .Select(s => new PlateOption { Width = s.Width, Length = s.Length, Cost = s.Width * s.Length })
+                .ToList();
+        }
+
+        public List<NestItem> CreateItems()
+        {
+            return Requests.Select(r => new NestItem
+            {
+                Drawing = r.Drawing,
+                Quantity = r.Quantity,
+                Priority = r.Priority,
+                StepAngle = r.StepAngle,
+                RotationStart = r.RotationStart,
+                RotationEnd = r.RotationEnd,
+            }).ToList();
+        }
+    }
+}

OpenNest.Benchmark/BenchmarkRunner.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+
+namespace OpenNest.Benchmark
+{
+    /// <summary>
+    /// Runs every candidate engine against every job. A job may need several
+    /// plates to place everything it asks for; this drives that loop itself,
+    /// since NestEngineBase.Nest() fills exactly one already-sized plate and
+    /// has no say in picking its own size. For each plate the loop needs, the
+    /// smallest candidate size that fits the largest still-unplaced drawing is
+    /// chosen via the codebase's own MultiPlateNester.CreatePlate, then the
+    /// engine's Nest() fills that plate with whatever of the remaining items
+    /// fit. This is applied identically to every engine, so no engine gets to
+    /// (or has to) implement sheet-size selection itself.
+    /// </summary>
+    public static class BenchmarkRunner
+    {
+        /// <summary>Safety cap so a degenerate engine (placing almost nothing
+        /// per plate) can't loop indefinitely.</summary>
+        private const int MaxPlates = 40;
+
+        public static List<JobResult> Run(List<BenchmarkJob> jobs, IReadOnlyList<NestEngineInfo> engines)
+        {
+            var results = new List<JobResult>(jobs.Count * engines.Count);
+
+            foreach (var job in jobs)
+            {
+                foreach (var engineInfo in engines)
+                {
+                    results.Add(RunOne(job, engineInfo));
+                }
+            }
+
+            return results;
+        }
+
+        private static JobResult RunOne(BenchmarkJob job, NestEngineInfo engineInfo)
+        {
+            var template = job.CreateTemplatePlate();
+            var options = job.BuildPlateOptions();
+            var remaining = job.CreateItems();
+            var requested = job.TotalRequestedQuantity;
+
+            var plateRuns = new List<(Plate Plate, List<Part> Parts)>();
+            string engineError = null;
+            var sw = Stopwatch.StartNew();
+
+            try
+            {
+                while (remaining.Any(i => i.Quantity > 0) && plateRuns.Count < MaxPlates)
+                {
+                    var largest = remaining
+                        .Where(i => i.Quantity > 0)
+                        .OrderByDescending(i => BoundsArea(i))
+                        .First();
+
+                    var plate = MultiPlateNester.CreatePlate(template, options, largest.Drawing.Program.BoundingBox());
+                    var engine = engineInfo.Factory(plate);
+                    var itemsClone = CloneItems(remaining);
+
+                    var parts = engine.Nest(itemsClone, null, CancellationToken.None) ?? new List<Part>();
+
+                    if (parts.Count == 0)
+                    {
+                        // Not even the largest available candidate size could fit
+                        // the current largest remaining part - stop here rather
+                        // than loop forever; whatever's left is reported unplaced.
+                        break;
+                    }
+
+                    plateRuns.Add((plate, parts));
+
+                    foreach (var item in remaining)
+                    {
+                        var placed = parts.Count(p => p.BaseDrawing.Id == item.Drawing.Id);
+
+                        if (placed > 0)
+                            item.Quantity = System.Math.Max(0, item.Quantity - placed);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                engineError = $"{ex.GetType().Name}: {ex.Message}";
+            }
+
+            sw.Stop();
+
+            if (engineError != null)
+            {
+                return new JobResult
+                {
+                    EngineName = engineInfo.Name,
+                    JobName = job.Name,
+                    Valid = false,
+                    PartsRequested = requested,
+                    ElapsedMs = sw.ElapsedMilliseconds,
+                    Error = engineError,
+                };
+            }
+
+            var validation = NestValidator.Validate(plateRuns, job);
+            var totalPlaced = plateRuns.Sum(pr => pr.Parts.Count);
+            var placedArea = validation.Valid ? plateRuns.Sum(pr => pr.Parts.Sum(p => p.BaseDrawing.Area)) : 0;
+            var plateArea = plateRuns.Sum(pr => pr.Plate.Area());
+
+            var sizeBreakdown = plateRuns
+                .GroupBy(pr => pr.Plate.Size.ToString(1))
+                .OrderByDescending(g => g.Count())
+                .ToDictionary(g => g.Key, g => g.Count());
+
+            return new JobResult
+            {
+                EngineName = engineInfo.Name,
+                JobName = job.Name,
+                Valid = validation.Valid,
+                Violations = validation.Violations,
+                PartsPlaced = totalPlaced,
+                PartsRequested = requested,
+                PlacedArea = placedArea,
+                PlateArea = plateArea,
+                PlatesUsed = plateRuns.Count,
+                SizeBreakdown = sizeBreakdown,
+                ElapsedMs = sw.ElapsedMilliseconds,
+            };
+        }
+
+        private static double BoundsArea(NestItem item)
+        {
+            var bb = item.Drawing.Program.BoundingBox();
+            return bb.Width * bb.Length;
+        }
+
+        private static List<NestItem> CloneItems(List<NestItem> items)
+        {
+            return items.Select(i => new NestItem
+            {
+                Drawing = i.Drawing,
+                Quantity = i.Quantity,
+                Priority = i.Priority,
+                StepAngle = i.StepAngle,
+                RotationStart = i.RotationStart,
+                RotationEnd = i.RotationEnd,
+            }).ToList();
+        }
+    }
+}

OpenNest.Benchmark/JobLoader.cs

@@ -0,0 +1,133 @@
+using OpenNest.Geometry;
+using OpenNest.IO;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace OpenNest.Benchmark
+{
+    /// <summary>
+    /// Builds BenchmarkJobs from .nest files on disk. Fully generic: works on
+    /// any valid .nest file, using whatever drawings/quantities/plate settings
+    /// it contains. One job per file, carrying the full pool of candidate
+    /// sheet sizes the engine may use across the whole nest - by default the
+    /// distinct sizes already present in that file, or a fixed override list
+    /// (e.g. a standard sheet-size lineup) applied to every file.
+    /// </summary>
+    public static class JobLoader
+    {
+        public static List<BenchmarkJob> Load(string inputPath, IReadOnlyList<Size> sheetSizeOverrides = null,
+            double? partSpacingOverride = null)
+        {
+            var files = ResolveFiles(inputPath);
+            var jobs = new List<BenchmarkJob>();
+
+            foreach (var file in files)
+            {
+                Nest nest;
+
+                try
+                {
+                    nest = new NestReader(file).Read();
+                }
+                catch (Exception ex)
+                {
+                    Console.Error.WriteLine($"[JobLoader] Skipping '{file}': failed to read ({ex.Message})");
+                    continue;
+                }
+
+                var requests = BuildRequests(nest);
+
+                if (requests.Count == 0)
+                {
+                    Console.Error.WriteLine($"[JobLoader] Skipping '{file}': no drawings with quantity > 0");
+                    continue;
+                }
+
+                var template = ResolvePlateTemplate(nest);
+                var sizes = sheetSizeOverrides != null && sheetSizeOverrides.Count > 0
+                    ? sheetSizeOverrides.ToList()
+                    : ResolveSheetSizes(nest);
+
+                jobs.Add(new BenchmarkJob
+                {
+                    SourceFile = file,
+                    CandidateSizes = sizes,
+                    EdgeSpacing = template.EdgeSpacing,
+                    PartSpacing = partSpacingOverride ?? template.PartSpacing,
+                    Quadrant = template.Quadrant,
+                    Requests = requests,
+                });
+            }
+
+            return jobs;
+        }
+
+        private static List<string> ResolveFiles(string inputPath)
+        {
+            if (Directory.Exists(inputPath))
+            {
+                return Directory.GetFiles(inputPath, "*.nest", SearchOption.AllDirectories)
+                    .OrderBy(f => f, StringComparer.OrdinalIgnoreCase)
+                    .ToList();
+            }
+
+            if (File.Exists(inputPath))
+                return new List<string> { inputPath };
+
+            throw new FileNotFoundException($"Benchmark input not found: {inputPath}");
+        }
+
+        private static List<DrawingRequest> BuildRequests(Nest nest)
+        {
+            var requests = new List<DrawingRequest>();
+
+            foreach (var drawing in nest.Drawings)
+            {
+                var qty = drawing.Quantity.Required;
+
+                if (qty <= 0)
+                    continue;
+
+                var constraints = drawing.Constraints;
+
+                requests.Add(new DrawingRequest
+                {
+                    Drawing = drawing,
+                    Quantity = qty,
+                    Priority = drawing.Priority,
+                    StepAngle = constraints?.StepAngle ?? 0,
+                    RotationStart = constraints?.StartAngle ?? 0,
+                    RotationEnd = constraints?.EndAngle ?? 0,
+                });
+            }
+
+            return requests;
+        }
+
+        private static (Spacing EdgeSpacing, double PartSpacing, int Quadrant) ResolvePlateTemplate(Nest nest)
+        {
+            var source = nest.Plates?.FirstOrDefault();
+
+            if (source != null)
+                return (source.EdgeSpacing, source.PartSpacing, source.Quadrant);
+
+            var defaults = nest.PlateDefaults;
+            return (defaults.EdgeSpacing, defaults.PartSpacing, defaults.Quadrant);
+        }
+
+        private static List<Size> ResolveSheetSizes(Nest nest)
+        {
+            var sizes = (nest.Plates ?? Enumerable.Empty<Plate>())
+                .Select(p => p.Size)
+                .Distinct()
+                .ToList();
+
+            if (sizes.Count == 0)
+                sizes.Add(nest.PlateDefaults.Size);
+
+            return sizes;
+        }
+    }
+}

OpenNest.Benchmark/JobResult.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+
+namespace OpenNest.Benchmark
+{
+    /// <summary>
+    /// Outcome of running one engine against one job. A job may span several
+    /// plates (PlatesUsed, SizeBreakdown), since the engine may need more than
+    /// one sheet - possibly of different sizes - to place everything asked of
+    /// it. An invalid or crashed run always scores zero utilization, per the
+    /// benchmark rules.
+    /// </summary>
+    public class JobResult
+    {
+        public string EngineName { get; init; }
+        public string JobName { get; init; }
+        public bool Valid { get; init; }
+        public List<string> Violations { get; init; } = new();
+        public string Error { get; init; }
+        public int PartsPlaced { get; init; }
+        public int PartsRequested { get; init; }
+        public double PlacedArea { get; init; }
+        public double PlateArea { get; init; }
+        public int PlatesUsed { get; init; }
+        public Dictionary<string, int> SizeBreakdown { get; init; } = new();
+        public long ElapsedMs { get; init; }
+
+        public bool Crashed => Error != null;
+        public bool FullyPlaced => Valid && PartsRequested > 0 && PartsPlaced >= PartsRequested;
+
+        /// <summary>Aggregate utilization across every plate the engine used:
+        /// total placed drawing area over total plate area, matching
+        /// Plate.Utilization()'s per-plate definition summed across the job.</summary>
+        public double Utilization => Valid && PlateArea > 0 ? PlacedArea / PlateArea : 0;
+    }
+}

OpenNest.Benchmark/NestValidator.cs

@@ -0,0 +1,183 @@
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.Math;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest.Benchmark
+{
+    public class ValidationResult
+    {
+        public bool Valid => Violations.Count == 0;
+        public List<string> Violations { get; } = new();
+    }
+
+    /// <summary>
+    /// Validates a (possibly multi-plate) placed layout against the benchmark
+    /// rules: on every plate, every part must lie within that plate's work
+    /// area and every pair of parts must be at least PartSpacing apart; across
+    /// all plates combined, no drawing may have more parts placed than
+    /// requested (the quantity limit is a property of the whole order, not of
+    /// any one plate). Geometry checks work on arbitrary (concave, holed)
+    /// polygons by reusing the same world-space extraction Part.Intersects
+    /// uses internally, so no engine gets an advantage or penalty from shape
+    /// complexity.
+    /// </summary>
+    public static class NestValidator
+    {
+        public static ValidationResult Validate(List<(Plate Plate, List<Part> Parts)> plateRuns, BenchmarkJob job)
+        {
+            var result = new ValidationResult();
+            var allParts = plateRuns.SelectMany(pr => pr.Parts).ToList();
+
+            if (allParts.Count == 0)
+                return result;
+
+            ValidateQuantities(allParts, job, result);
+
+            foreach (var (plate, parts) in plateRuns)
+            {
+                if (parts.Count == 0)
+                    continue;
+
+                ValidateBounds(parts, plate, result);
+                ValidateAreaBudget(parts, plate, result);
+                ValidateSpacing(parts, plate.PartSpacing, result);
+            }
+
+            return result;
+        }
+
+        private static void ValidateQuantities(List<Part> parts, BenchmarkJob job, ValidationResult result)
+        {
+            var allowed = job.Requests.ToDictionary(r => r.Drawing.Id, r => r.Quantity);
+            var placedCounts = parts
+                .GroupBy(p => p.BaseDrawing.Id)
+                .ToDictionary(g => g.Key, g => g.Count());
+
+            foreach (var (drawingId, placed) in placedCounts)
+            {
+                if (!allowed.TryGetValue(drawingId, out var max))
+                {
+                    result.Violations.Add($"Placed drawing id={drawingId} which was not requested for this job");
+                    continue;
+                }
+
+                if (placed > max)
+                {
+                    var name = parts.First(p => p.BaseDrawing.Id == drawingId).BaseDrawing.Name;
+                    result.Violations.Add($"'{name}': placed {placed} across all plates but only {max} were requested");
+                }
+            }
+        }
+
+        private static void ValidateBounds(List<Part> parts, Plate plate, ValidationResult result)
+        {
+            var workArea = plate.WorkArea();
+
+            foreach (var part in parts)
+            {
+                var bb = part.BoundingBox;
+
+                var outLeft = bb.Left < workArea.X - Tolerance.Epsilon;
+                var outBottom = bb.Bottom < workArea.Y - Tolerance.Epsilon;
+                var outRight = bb.Right > workArea.Right + Tolerance.Epsilon;
+                var outTop = bb.Top > workArea.Top + Tolerance.Epsilon;
+
+                if (outLeft || outBottom || outRight || outTop)
+                {
+                    result.Violations.Add(
+                        $"'{part.BaseDrawing.Name}' at ({part.Location.X:F2},{part.Location.Y:F2}) falls outside the work area " +
+                        $"of a {plate.Size} plate");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Hard mathematical backstop: non-overlapping parts confined to the
+        /// work area can never have a combined area greater than the work
+        /// area itself. This catches overlap that the polygon-based
+        /// ValidateSpacing check can miss - Collision.HasOverlap (and
+        /// Part.Intersects, which uses the same algorithm) has been observed
+        /// to return false negatives on real, complex production geometry, so
+        /// this check does not depend on it.
+        /// </summary>
+        private static void ValidateAreaBudget(List<Part> parts, Plate plate, ValidationResult result)
+        {
+            var workArea = plate.WorkArea();
+            var budget = workArea.Width * workArea.Length;
+            var placedArea = parts.Sum(p => p.BaseDrawing.Area);
+
+            if (placedArea > budget + Tolerance.Epsilon)
+            {
+                result.Violations.Add(
+                    $"Combined placed area ({placedArea:F2}) on a {plate.Size} plate exceeds its work area ({budget:F2}) - " +
+                    "parts must overlap even though the polygon overlap check did not flag a pair");
+            }
+        }
+
+        private static void ValidateSpacing(List<Part> parts, double spacing, ValidationResult result)
+        {
+            var worldPolygons = new Polygon[parts.Count];
+            var inflatedPolygons = new Polygon[parts.Count];
+
+            for (var i = 0; i < parts.Count; i++)
+            {
+                worldPolygons[i] = WorldPolygon(parts[i], 0);
+                inflatedPolygons[i] = spacing > Tolerance.Epsilon ? WorldPolygon(parts[i], spacing) : worldPolygons[i];
+            }
+
+            for (var i = 0; i < parts.Count; i++)
+            {
+                if (worldPolygons[i] == null || inflatedPolygons[i] == null)
+                    continue;
+
+                for (var j = i + 1; j < parts.Count; j++)
+                {
+                    if (worldPolygons[j] == null)
+                        continue;
+
+                    if (Collision.HasOverlap(inflatedPolygons[i], worldPolygons[j]))
+                    {
+                        result.Violations.Add(
+                            $"'{parts[i].BaseDrawing.Name}' and '{parts[j].BaseDrawing.Name}' are closer than the required spacing ({spacing:F3})");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Extracts a part's perimeter as a world-space polygon, optionally inflated
+        /// outward by the given spacing, mirroring Part.Intersects' own geometry
+        /// extraction (part.Program is already rotated; only a Location offset is needed).
+        /// </summary>
+        private static Polygon WorldPolygon(Part part, double inflateBy)
+        {
+            var entities = ConvertProgram.ToGeometry(part.Program)
+                .Where(e => e.Layer != SpecialLayers.Rapid)
+                .ToList();
+
+            if (entities.Count == 0)
+                return null;
+
+            var perimeter = new ShapeProfile(entities).Perimeter;
+
+            if (perimeter == null)
+                return null;
+
+            if (inflateBy > Tolerance.Epsilon)
+                perimeter = perimeter.OffsetOutward(inflateBy) ?? perimeter;
+
+            // Adaptive tolerance instead of Shape.ToPolygon()'s default (up to 1000
+            // segments per arc) - arc-heavy real parts otherwise produce thousands
+            // of vertices, which is needlessly slow for a spacing check.
+            var polygon = perimeter.ToPolygonWithTolerance(0.01, circumscribe: true);
+
+            if (polygon == null)
+                return null;
+
+            polygon.Offset(part.Location);
+            return polygon;
+        }
+    }
+}

OpenNest.Benchmark/OpenNest.Benchmark.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <RootNamespace>OpenNest.Benchmark</RootNamespace>
+    <AssemblyName>OpenNest.Benchmark</AssemblyName>
+    <Nullable>disable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />
+    <ProjectReference Include="..\OpenNest.Engine\OpenNest.Engine.csproj" />
+    <ProjectReference Include="..\OpenNest.IO\OpenNest.IO.csproj" />
+  </ItemGroup>
+</Project>

OpenNest.Benchmark/Program.cs

@@ -0,0 +1,172 @@
+using OpenNest;
+using OpenNest.Benchmark;
+using OpenNest.Geometry;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+return BenchmarkConsole.Run(args);
+
+static class BenchmarkConsole
+{
+    public static int Run(string[] args)
+    {
+        var options = ParseArgs(args);
+
+        if (options == null)
+            return 0; // --help was requested
+
+        if (options.InputPath == null)
+        {
+            PrintUsage();
+            return 1;
+        }
+
+        List<BenchmarkJob> jobs;
+
+        try
+        {
+            jobs = JobLoader.Load(options.InputPath, options.SheetSizes, options.PartSpacing);
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+
+        if (jobs.Count == 0)
+        {
+            Console.Error.WriteLine("No benchmark jobs found (no .nest files with any drawing quantity > 0).");
+            return 1;
+        }
+
+        var engines = NestEngineRegistry.AvailableEngines;
+
+        if (options.EngineNames.Count > 0)
+        {
+            engines = engines
+                .Where(e => options.EngineNames.Any(n => n.Equals(e.Name, StringComparison.OrdinalIgnoreCase)))
+                .ToList();
+
+            if (engines.Count == 0)
+            {
+                Console.Error.WriteLine("None of the requested engines are registered. Available: " +
+                    string.Join(", ", NestEngineRegistry.AvailableEngines.Select(e => e.Name)));
+                return 1;
+            }
+        }
+
+        Console.WriteLine($"Loaded {jobs.Count} job(s) from '{options.InputPath}'");
+
+        foreach (var job in jobs)
+        {
+            var sizes = string.Join(", ", job.CandidateSizes.Select(s => s.ToString(1)));
+            Console.WriteLine($"  {job.Name}: {job.Requests.Count} drawing(s), {job.TotalRequestedQuantity} part(s) requested, candidate sizes: {sizes}");
+        }
+
+        Console.WriteLine($"Engines: {string.Join(", ", engines.Select(e => e.Name))}");
+
+        var results = BenchmarkRunner.Run(jobs, engines);
+
+        Report.PrintDetailed(results);
+        Report.PrintSummary(results);
+
+        if (options.CsvPath != null)
+        {
+            Report.WriteCsv(options.CsvPath, results);
+            Console.WriteLine();
+            Console.WriteLine($"Wrote CSV report to {options.CsvPath}");
+        }
+
+        return 0;
+    }
+
+    private static Options ParseArgs(string[] args)
+    {
+        var o = new Options();
+
+        for (var i = 0; i < args.Length; i++)
+        {
+            switch (args[i])
+            {
+                case "--sheet-sizes" when i + 1 < args.Length:
+                    o.SheetSizes = ParseSheetSizes(args[++i]);
+                    break;
+
+                case "--spacing" when i + 1 < args.Length:
+                    o.PartSpacing = double.Parse(args[++i]);
+                    break;
+
+                case "--engines" when i + 1 < args.Length:
+                    o.EngineNames = args[++i]
+                        .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+                        .ToList();
+                    break;
+
+                case "--csv" when i + 1 < args.Length:
+                    o.CsvPath = args[++i];
+                    break;
+
+                case "--help":
+                    PrintUsage();
+                    return null;
+
+                default:
+                    if (!args[i].StartsWith("--"))
+                        o.InputPath = args[i];
+                    break;
+            }
+        }
+
+        return o;
+    }
+
+    private static List<Size> ParseSheetSizes(string arg)
+    {
+        var sizes = new List<Size>();
+
+        foreach (var token in arg.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+        {
+            if (Size.TryParse(token, out var size))
+                sizes.Add(size);
+            else
+                Console.Error.WriteLine($"Warning: could not parse sheet size '{token}', skipping");
+        }
+
+        return sizes;
+    }
+
+    private static void PrintUsage()
+    {
+        Console.Error.WriteLine("OpenNest.Benchmark - compare registered nesting engines on a set of .nest files");
+        Console.Error.WriteLine();
+        Console.Error.WriteLine("For each .nest file, every drawing with quantity > 0 is nested (mixed together),");
+        Console.Error.WriteLine("once per registered engine. This is a full nest, not a single fixed-size plate:");
+        Console.Error.WriteLine("as many plates as needed are created, one at a time, each sized by picking the");
+        Console.Error.WriteLine("smallest candidate sheet size that fits the largest still-unplaced drawing -");
+        Console.Error.WriteLine("applied identically to every engine, since Nest() itself has no say over its");
+        Console.Error.WriteLine("own plate's size. Scoring: aggregate material utilization across every plate");
+        Console.Error.WriteLine("used, then (if everything requested was placed) fewer plates as the tie-break.");
+        Console.Error.WriteLine("An invalid layout (out of bounds, overlapping, or over-quantity) scores zero.");
+        Console.Error.WriteLine();
+        Console.Error.WriteLine("Usage:");
+        Console.Error.WriteLine("  OpenNest.Benchmark <file.nest | folder> [options]");
+        Console.Error.WriteLine();
+        Console.Error.WriteLine("Options:");
+        Console.Error.WriteLine("  --sheet-sizes W1xL1,W2xL2,...  Candidate sheet-size pool for the whole nest");
+        Console.Error.WriteLine("                                 (default: the distinct sizes already in each file)");
+        Console.Error.WriteLine("  --spacing <value>               Override part spacing for every job");
+        Console.Error.WriteLine("  --engines Name1,Name2,...       Only benchmark these registered engines (default: all)");
+        Console.Error.WriteLine("  --csv <path>                    Write a flat CSV of all results");
+        Console.Error.WriteLine("  --help                          Show this message");
+    }
+
+    private class Options
+    {
+        public string InputPath;
+        public List<Size> SheetSizes = new();
+        public double? PartSpacing;
+        public List<string> EngineNames = new();
+        public string CsvPath;
+    }
+}

OpenNest.Benchmark/Report.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace OpenNest.Benchmark
+{
+    /// <summary>
+    /// Console + CSV reporting for benchmark results. Ranking rule per job:
+    /// valid beats invalid; higher aggregate utilization wins; if utilization
+    /// ties and both engines fully placed every requested part, fewer plates
+    /// used wins (the multi-plate analogue of "smaller remnant" - both are
+    /// proxies for wasting less material). Ties beyond that are a shared win.
+    /// </summary>
+    public static class Report
+    {
+        private const double Epsilon = 1e-6;
+
+        public static void PrintDetailed(List<JobResult> results)
+        {
+            foreach (var jobGroup in results.GroupBy(r => r.JobName))
+            {
+                Console.WriteLine();
+                Console.WriteLine($"=== {jobGroup.Key} ===");
+
+                var ranked = jobGroup.OrderBy(r => r, Comparer<JobResult>.Create(Compare)).ToList();
+                var best = ranked.Count > 0 ? ranked[0] : null;
+
+                Console.WriteLine($"{"Engine",-16} {"Result",-9} {"Parts",-10} {"Util%",-8} {"Plates",-18} {"Time(ms)",-9} Notes");
+
+                foreach (var r in ranked)
+                {
+                    var isWinner = best != null && Compare(r, best) == 0 && r.Valid;
+                    var marker = isWinner ? "*" : " ";
+                    var status = r.Crashed ? "CRASH" : r.Valid ? "ok" : "INVALID";
+                    var partsCol = $"{r.PartsPlaced}/{r.PartsRequested}";
+                    var utilCol = r.Valid ? $"{r.Utilization * 100:F1}" : "-";
+                    var platesCol = r.PlatesUsed > 0 ? $"{r.PlatesUsed} ({SizeSummary(r.SizeBreakdown)})" : "-";
+                    var notes = r.Crashed ? r.Error : string.Join("; ", r.Violations.Take(2));
+
+                    Console.WriteLine($"{marker}{r.EngineName,-15} {status,-9} {partsCol,-10} {utilCol,-8} {platesCol,-18} {r.ElapsedMs,-9} {notes}");
+                }
+            }
+        }
+
+        public static void PrintSummary(List<JobResult> results)
+        {
+            Console.WriteLine();
+            Console.WriteLine("=== Summary ===");
+
+            var byEngine = results
+                .GroupBy(r => r.EngineName)
+                .Select(g => new
+                {
+                    Engine = g.Key,
+                    Jobs = g.Count(),
+                    Valid = g.Count(r => r.Valid),
+                    Crashed = g.Count(r => r.Crashed),
+                    FullyPlaced = g.Count(r => r.FullyPlaced),
+                    TotalUtilization = g.Sum(r => r.Utilization),
+                    TotalPlates = g.Sum(r => r.PlatesUsed),
+                    TotalTimeMs = g.Sum(r => r.ElapsedMs),
+                })
+                .OrderByDescending(e => e.TotalUtilization)
+                .ToList();
+
+            var wins = CountWins(results);
+
+            Console.WriteLine($"{"Engine",-16} {"Jobs",-6} {"Valid",-7} {"Complete",-9} {"Wins",-6} {"AvgUtil%",-10} {"Plates",-8} {"TotalTime(ms)",-14}");
+
+            foreach (var e in byEngine)
+            {
+                var avgUtil = e.Jobs > 0 ? e.TotalUtilization / e.Jobs * 100 : 0;
+                var winCount = wins.TryGetValue(e.Engine, out var w) ? w : 0;
+                Console.WriteLine($"{e.Engine,-16} {e.Jobs,-6} {e.Valid,-7} {e.FullyPlaced,-9} {winCount,-6} {avgUtil,-10:F1} {e.TotalPlates,-8} {e.TotalTimeMs,-14}");
+            }
+        }
+
+        public static void WriteCsv(string path, List<JobResult> results)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("Job,Engine,Valid,Crashed,FullyPlaced,PartsPlaced,PartsRequested,Utilization,PlatesUsed,SizeBreakdown,ElapsedMs,Notes");
+
+            foreach (var r in results)
+            {
+                var notes = r.Crashed ? r.Error : string.Join(" | ", r.Violations);
+                sb.AppendLine(string.Join(",",
+                    Csv(r.JobName), Csv(r.EngineName), r.Valid, r.Crashed, r.FullyPlaced,
+                    r.PartsPlaced, r.PartsRequested,
+                    r.Utilization.ToString("F4", CultureInfo.InvariantCulture),
+                    r.PlatesUsed, Csv(SizeSummary(r.SizeBreakdown)),
+                    r.ElapsedMs, Csv(notes)));
+            }
+
+            File.WriteAllText(path, sb.ToString());
+        }
+
+        private static string SizeSummary(Dictionary<string, int> breakdown)
+        {
+            if (breakdown == null || breakdown.Count == 0)
+                return "-";
+
+            return string.Join("; ", breakdown.Select(kv => $"{kv.Key}×{kv.Value}"));
+        }
+
+        private static string Csv(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+                return string.Empty;
+
+            if (value.Contains(',') || value.Contains('"') || value.Contains('\n'))
+                return $"\"{value.Replace("\"", "\"\"")}\"";
+
+            return value;
+        }
+
+        private static Dictionary<string, int> CountWins(List<JobResult> results)
+        {
+            var wins = new Dictionary<string, int>();
+
+            foreach (var jobGroup in results.GroupBy(r => r.JobName))
+            {
+                var ranked = jobGroup.OrderBy(r => r, Comparer<JobResult>.Create(Compare)).ToList();
+
+                if (ranked.Count == 0 || !ranked[0].Valid)
+                    continue;
+
+                foreach (var r in ranked.TakeWhile(r => Compare(r, ranked[0]) == 0))
+                    wins[r.EngineName] = wins.GetValueOrDefault(r.EngineName) + 1;
+            }
+
+            return wins;
+        }
+
+        /// <summary>Lower sorts first (better). Valid beats invalid, then higher
+        /// aggregate utilization, then (if both fully placed) fewer plates used.</summary>
+        private static int Compare(JobResult a, JobResult b)
+        {
+            if (a.Valid != b.Valid)
+                return a.Valid ? -1 : 1;
+
+            if (!a.Valid)
+                return 0;
+
+            var utilDiff = b.Utilization - a.Utilization;
+
+            if (System.Math.Abs(utilDiff) > Epsilon)
+                return utilDiff > 0 ? 1 : -1;
+
+            if (a.FullyPlaced && b.FullyPlaced && a.PlatesUsed != b.PlatesUsed)
+                return a.PlatesUsed > b.PlatesUsed ? 1 : -1;
+
+            return 0;
+        }
+    }
+}

OpenNest.Console/Program.cs

@@ -41,7 +41,6 @@ static class NestConsole
             }
         }
 
-        using var log = SetUpLog(options);
         var nest = LoadOrCreateNest(options);
 
         if (nest == null)
@@ -68,10 +67,6 @@ static class NestConsole
 
         var overlapCount = CheckOverlaps(plate, options);
 
-        // Flush and close the log before printing results.
-        Trace.Flush();
-        log?.Dispose();
-
         PrintResults(success, plate, elapsed);
         Save(nest, options);
         PostProcess(nest, options);
@@ -112,9 +107,6 @@ static class NestConsole
                 case "--no-save":
                     o.NoSave = true;
                     break;
-                case "--no-log":
-                    o.NoLog = true;
-                    break;
                 case "--keep-parts":
                     o.KeepParts = true;
                     break;
@@ -153,28 +145,14 @@ static class NestConsole
         return o;
     }
 
-    static StreamWriter SetUpLog(Options options)
-    {
-        if (options.NoLog)
-            return null;
-
-        var baseDir = Path.GetDirectoryName(options.InputFiles[0]);
-        var logDir = Path.Combine(baseDir, "test-harness-logs");
-        Directory.CreateDirectory(logDir);
-        var logFile = Path.Combine(logDir, $"debug-{DateTime.Now:yyyyMMdd-HHmmss}.log");
-        var writer = new StreamWriter(logFile) { AutoFlush = true };
-        Trace.Listeners.Add(new TextWriterTraceListener(writer));
-        Console.WriteLine($"Debug log: {logFile}");
-        return writer;
-    }
-
     static Nest LoadOrCreateNest(Options options)
     {
         var nestFile = options.InputFiles.FirstOrDefault(f =>
             f.EndsWith(NestFormat.FileExtension, StringComparison.OrdinalIgnoreCase)
             || f.EndsWith(".zip", StringComparison.OrdinalIgnoreCase));
         var dxfFiles = options.InputFiles.Where(f =>
-            f.EndsWith(".dxf", StringComparison.OrdinalIgnoreCase)).ToList();
+            f.EndsWith(".dxf", StringComparison.OrdinalIgnoreCase) ||
+            f.EndsWith(".dwg", StringComparison.OrdinalIgnoreCase)).ToList();
 
         // If we have a nest file, load it and optionally add DXFs.
         if (nestFile != null)
@@ -210,7 +188,7 @@ static class NestConsole
         // DXF-only mode: create a fresh nest.
         if (dxfFiles.Count == 0)
         {
-            Console.Error.WriteLine("Error: no nest (.nest) or DXF (.dxf) files specified");
+            Console.Error.WriteLine("Error: no nest (.nest) or CAD (.dxf/.dwg) files specified");
             return null;
         }
 
@@ -484,7 +462,7 @@ static class NestConsole
         Console.Error.WriteLine("Usage: OpenNest.Console <input-files...> [options]");
         Console.Error.WriteLine();
         Console.Error.WriteLine("Arguments:");
-        Console.Error.WriteLine("  input-files            One or more .nest nest files or .dxf drawing files");
+        Console.Error.WriteLine("  input-files            One or more .nest nest files or .dxf/.dwg drawing files");
         Console.Error.WriteLine();
         Console.Error.WriteLine("Modes:");
         Console.Error.WriteLine("  <nest.nest>             Load nest and fill (existing behavior)");
@@ -503,7 +481,6 @@ static class NestConsole
         Console.Error.WriteLine("  --keep-parts           Don't clear existing parts before filling");
         Console.Error.WriteLine("  --check-overlaps       Run overlap detection after fill (exit code 1 if found)");
         Console.Error.WriteLine("  --no-save              Skip saving output file");
-        Console.Error.WriteLine("  --no-log               Skip writing debug log file");
         Console.Error.WriteLine("  --post <name>          Run a post processor after nesting");
         Console.Error.WriteLine("  --post-output <path>   Output file for post processor (default: <input>.cnc)");
         Console.Error.WriteLine("  --posts-dir <path>     Directory containing post processor DLLs (default: Posts/)");
@@ -522,7 +499,6 @@ static class NestConsole
         public Size? PlateSize;
         public bool CheckOverlaps;
         public bool NoSave;
-        public bool NoLog;
         public bool KeepParts;
         public bool AutoNest;
         public string TemplateFile;

OpenNest.Core/Bending/Bend.cs

@@ -26,6 +26,10 @@ namespace OpenNest.Bending
         [System.Text.Json.Serialization.JsonIgnore]
         public Entity SourceEntity { get; set; }
 
+        // Import-only identity of the original CAD annotation (not nest metadata).
+        [System.Text.Json.Serialization.JsonIgnore]
+        public ulong? SourceNoteHandle { get; set; }
+
         public double Length => StartPoint.DistanceTo(EndPoint);
 
         public double AngleRadians => Angle.HasValue

OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs

@@ -69,9 +69,17 @@ namespace OpenNest.CNC.CuttingStrategy
             EmitScribeContours(result, scribeEntities);
 
             foreach (var entry in cutoutEntries)
-                EmitContour(result, entry.Shape, entry.Point, entry.Entity);
+            {
+                if (!entry.Shape.IsClosed())
+                    EmitRawContour(result, entry.Shape);
+                else
+                    EmitContour(result, entry.Shape, entry.Point, entry.Entity);
+            }
 
-            EmitContour(result, profile.Perimeter, perimeterPt, perimeterEntity, ContourType.External);
+            if (!profile.Perimeter.IsClosed())
+                EmitRawContour(result, profile.Perimeter);
+            else
+                EmitContour(result, profile.Perimeter, perimeterPt, perimeterEntity, ContourType.External);
 
             result.Mode = Mode.Incremental;
 
@@ -99,10 +107,14 @@ namespace OpenNest.CNC.CuttingStrategy
             // Find the target shape that contains the clicked entity
             var (targetShape, matchedEntity) = FindTargetShape(profile, point, entity);
 
-            // Emit cutouts — only the target gets lead-in/out
+            // Emit cutouts — only the target gets lead-in/out (skip open contours)
             foreach (var cutout in profile.Cutouts)
             {
-                if (cutout == targetShape)
+                if (!cutout.IsClosed())
+                {
+                    EmitRawContour(result, cutout);
+                }
+                else if (cutout == targetShape)
                 {
                     var ct = DetectContourType(cutout);
                     EmitContour(result, cutout, point, matchedEntity, ct);
@@ -114,7 +126,11 @@ namespace OpenNest.CNC.CuttingStrategy
             }
 
             // Emit perimeter
-            if (profile.Perimeter == targetShape)
+            if (!profile.Perimeter.IsClosed())
+            {
+                EmitRawContour(result, profile.Perimeter);
+            }
+            else if (profile.Perimeter == targetShape)
             {
                 EmitContour(result, profile.Perimeter, point, matchedEntity, ContourType.External);
             }
@@ -289,9 +305,6 @@ namespace OpenNest.CNC.CuttingStrategy
                 subPgm.Codes.AddRange(leadIn.Generate(relativePoint, normal, winding));
                 var reindexed = relativeShape.ReindexAt(relativePoint, relativeCircle);
 
-                if (Parameters.TabsEnabled && Parameters.TabConfig != null)
-                    reindexed = TrimShapeForTab(reindexed, relativePoint, Parameters.TabConfig.Size);
-
                 subPgm.Codes.AddRange(ConvertShapeToMoves(reindexed, relativePoint));
                 subPgm.Codes.AddRange(leadOut.Generate(relativePoint, normal, winding));
                 subPgm.Mode = Mode.Incremental;
@@ -315,7 +328,7 @@ namespace OpenNest.CNC.CuttingStrategy
 
             var reindexedShape = shape.ReindexAt(point, entity);
 
-            if (Parameters.TabsEnabled && Parameters.TabConfig != null)
+            if (Parameters.TabsEnabled && Parameters.TabConfig != null && contourType == ContourType.External)
                 reindexedShape = TrimShapeForTab(reindexedShape, point, Parameters.TabConfig.Size);
 
             program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));

OpenNest.Core/CNC/RapidEnumerator.cs

@@ -0,0 +1,80 @@
+using OpenNest.Geometry;
+using System.Collections.Generic;
+
+namespace OpenNest.CNC
+{
+    public static class RapidEnumerator
+    {
+        public readonly record struct Segment(Vector From, Vector To);
+
+        public static List<Segment> Enumerate(Program pgm, Vector basePos, Vector startPos)
+        {
+            var results = new List<Segment>();
+
+            // Draw the rapid from the previous tool position to the program's first
+            // pierce point. This also primes pos so the interior walk interprets
+            // Incremental deltas from the correct absolute location (basePos), which
+            // matters for raw pre-lead-in programs that are emitted Incremental.
+            var firstPierce = FirstPiercePoint(pgm, basePos);
+            results.Add(new Segment(startPos, firstPierce));
+
+            var pos = firstPierce;
+            Walk(pgm, basePos, ref pos, skipFirst: true, results);
+            return results;
+        }
+
+        private static Vector FirstPiercePoint(Program pgm, Vector basePos)
+        {
+            for (var i = 0; i < pgm.Length; i++)
+            {
+                if (pgm[i] is SubProgramCall call && call.Program != null)
+                    return FirstPiercePoint(call.Program, basePos + call.Offset);
+
+                if (pgm[i] is Motion motion)
+                    return motion.EndPoint + basePos;
+            }
+            return basePos;
+        }
+
+        private static void Walk(Program pgm, Vector basePos, ref Vector pos, bool skipFirst, List<Segment> results)
+        {
+            var skipped = !skipFirst;
+
+            for (var i = 0; i < pgm.Length; ++i)
+            {
+                var code = pgm[i];
+
+                if (code is SubProgramCall { Program: { } program } call)
+                {
+                    var holeBase = basePos + call.Offset;
+                    var firstPierce = FirstPiercePoint(program, holeBase);
+
+                    if (!skipped)
+                        skipped = true;
+                    else
+                        results.Add(new Segment(pos, firstPierce));
+
+                    var subPos = holeBase;
+                    Walk(program, holeBase, ref subPos, skipFirst: true, results);
+                    pos = subPos;
+                }
+                else if (code is Motion motion)
+                {
+                    var endpt = pgm.Mode == Mode.Incremental
+                        ? motion.EndPoint + pos
+                        : motion.EndPoint + basePos;
+
+                    if (code.Type == CodeType.RapidMove)
+                    {
+                        if (!skipped)
+                            skipped = true;
+                        else
+                            results.Add(new Segment(pos, endpt));
+                    }
+
+                    pos = endpt;
+                }
+            }
+        }
+    }
+}

OpenNest.Core/CanonicalAngle.cs

@@ -0,0 +1,78 @@
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using System.Linq;
+
+namespace OpenNest
+{
+    /// <summary>
+    /// Computes the rotation that maps a drawing to its canonical (MBR-axis-aligned) frame.
+    /// Lives in OpenNest.Core so Drawing.Program setter can invoke it directly without
+    /// a circular dependency on OpenNest.Engine.
+    /// </summary>
+    public static class CanonicalAngle
+    {
+        /// <summary>Angles with |v| below this (radians) are snapped to 0.</summary>
+        public const double SnapToZero = 0.001;
+
+        /// <summary>
+        /// Derives the canonical angle from a pre-computed MBR. Used both by Compute (which
+        /// computes the MBR itself) and by PartClassifier (which already has one). Single formula
+        /// across both callers.
+        /// </summary>
+        public static double FromMbr(BoundingRectangleResult mbr)
+        {
+            if (mbr.Area <= OpenNest.Math.Tolerance.Epsilon)
+                return 0.0;
+
+            // The MBR edge angle can represent any of four equivalent orientations
+            // (edge-i, edge-i + π/2, edge-i + π, edge-i - π/2) depending on which hull
+            // edge the algorithm happened to pick. Normalize -mbr.Angle to the
+            // representative in [-π/4, π/4] so snap-to-zero works for inputs near
+            // ANY of the equivalent orientations.
+            var angle = -mbr.Angle;
+            const double halfPi = System.Math.PI / 2.0;
+            angle -= halfPi * System.Math.Round(angle / halfPi);
+
+            if (System.Math.Abs(angle) < SnapToZero)
+                return 0.0;
+
+            return angle;
+        }
+
+        public static double Compute(Drawing drawing)
+        {
+            if (drawing?.Program == null)
+                return 0.0;
+
+            var entities = ConvertProgram.ToGeometry(drawing.Program)
+                .Where(e => e.Layer != SpecialLayers.Rapid);
+
+            var shapes = ShapeBuilder.GetShapes(entities);
+            if (shapes.Count == 0)
+                return 0.0;
+
+            var perimeter = shapes[0];
+            var perimeterArea = perimeter.Area();
+            for (var i = 1; i < shapes.Count; i++)
+            {
+                var area = shapes[i].Area();
+                if (area > perimeterArea)
+                {
+                    perimeter = shapes[i];
+                    perimeterArea = area;
+                }
+            }
+
+            var polygon = perimeter.ToPolygonWithTolerance(0.1);
+            if (polygon == null || polygon.Vertices.Count < 3)
+                return 0.0;
+
+            var hull = ConvexHull.Compute(polygon.Vertices);
+            if (hull.Vertices.Count < 3)
+                return 0.0;
+
+            var mbr = RotatingCalipers.MinimumBoundingRectangle(hull);
+            return FromMbr(mbr);
+        }
+    }
+}

OpenNest.Core/Converters/ConvertGeometry.cs

@@ -1,5 +1,6 @@
 using OpenNest.CNC;
 using OpenNest.Geometry;
+using OpenNest.Math;
 using System.Collections.Generic;
 
 namespace OpenNest.Converters
@@ -81,12 +82,21 @@ namespace OpenNest.Converters
             var startpt = arc.StartPoint();
             var endpt = arc.EndPoint();
 
-            if (startpt != lastpt)
+            if (startpt.DistanceTo(lastpt) > Tolerance.ChainTolerance)
                 pgm.MoveTo(startpt);
 
             lastpt = endpt;
 
-            pgm.ArcTo(endpt, arc.Center, arc.IsReversed ? RotationType.CW : RotationType.CCW);
+            var sweep = System.Math.Abs(arc.SweepAngle());
+            if (sweep < Tolerance.Epsilon || sweep.IsEqualTo(Angle.TwoPI))
+            {
+                pgm.LineTo(endpt);
+            }
+            else
+            {
+                pgm.ArcTo(endpt, arc.Center, arc.IsReversed ? RotationType.CW : RotationType.CCW);
+            }
+
             return lastpt;
         }
 
@@ -94,7 +104,7 @@ namespace OpenNest.Converters
         {
             var startpt = new Vector(circle.Center.X + circle.Radius, circle.Center.Y);
 
-            if (startpt != lastpt)
+            if (startpt.DistanceTo(lastpt) > Tolerance.ChainTolerance)
                 pgm.MoveTo(startpt);
 
             pgm.ArcTo(startpt, circle.Center, circle.Rotation);
@@ -105,7 +115,7 @@ namespace OpenNest.Converters
 
         private static Vector AddLine(Program pgm, Vector lastpt, Line line)
         {
-            if (line.StartPoint != lastpt)
+            if (line.StartPoint.DistanceTo(lastpt) > Tolerance.ChainTolerance)
                 pgm.MoveTo(line.StartPoint);
 
             var move = new LinearMove(line.EndPoint);

OpenNest.Core/Drawing.cs

@@ -16,7 +16,7 @@ namespace OpenNest
         private static int nextColorIndex;
         private Program program;
 
-        public static readonly Color[] PartColors = new Color[]
+        public static Color[] PartColors = new Color[]
         {
             Color.FromArgb(205, 92, 92),    // Indian Red
             Color.FromArgb(148, 103, 189),  // Medium Purple
@@ -54,9 +54,9 @@ namespace OpenNest
             Id = Interlocked.Increment(ref nextId);
             Name = name;
             Material = new Material();
-            Program = pgm;
             Constraints = new NestConstraints();
             Source = new SourceInfo();
+            Program = pgm;
         }
 
         public int Id { get; }
@@ -78,9 +78,29 @@ namespace OpenNest
             {
                 program = value;
                 UpdateArea();
+                RecomputeCanonicalAngle();
             }
         }
 
+        /// <summary>
+        /// Recomputes and stores the canonical angle from the current Program.
+        /// Callers that mutate Program in place (rather than reassigning it) must invoke this explicitly.
+        /// Cut-off drawings are left with Angle=0.
+        /// </summary>
+        public void RecomputeCanonicalAngle()
+        {
+            if (Source == null)
+                Source = new SourceInfo();
+
+            if (program == null || IsCutOff)
+            {
+                Source.Angle = 0.0;
+                return;
+            }
+
+            Source.Angle = CanonicalAngle.Compute(this);
+        }
+
         public Color Color { get; set; }
 
         public bool IsCutOff { get; set; }
@@ -163,5 +183,15 @@ namespace OpenNest
         /// Offset distances to the original location.
         /// </summary>
         public Vector Offset { get; set; }
+
+        /// <summary>
+        /// Rotation (radians) that maps the source program geometry to its canonical
+        /// (MBR-axis-aligned) frame. Populated automatically by the <see cref="Drawing.Program"/>
+        /// setter via <see cref="CanonicalAngle.Compute"/>. A value of 0 means the drawing is
+        /// already canonical or <see cref="Drawing.IsCutOff"/> is true. Callers that mutate
+        /// <see cref="Drawing.Program"/> in place must invoke
+        /// <see cref="Drawing.RecomputeCanonicalAngle"/> to refresh.
+        /// </summary>
+        public double Angle { get; set; }
     }
 }

OpenNest.Core/Geometry/Arc.cs

@@ -93,6 +93,9 @@ namespace OpenNest.Geometry
             }
         }
 
+        public bool IsFullCircle() =>
+            SweepAngle() >= Angle.TwoPI - Tolerance.Epsilon;
+
         /// <summary>
         /// Angle in radians between start and end angles.
         /// </summary>
@@ -267,6 +270,13 @@ namespace OpenNest.Geometry
             get { return Diameter * System.Math.PI * SweepAngle() / Angle.TwoPI; }
         }
 
+        public override Entity Clone()
+        {
+            var copy = new Arc(center, radius, startAngle, endAngle, reversed);
+            CopyBaseTo(copy);
+            return copy;
+        }
+
         /// <summary>
         /// Reverses the rotation direction.
         /// </summary>
@@ -397,26 +407,29 @@ namespace OpenNest.Geometry
                 maxY = startpt.Y;
             }
 
-            var angle1 = StartAngle;
-            var angle2 = EndAngle;
+            var sweep = SweepAngle();
+            if (sweep > Tolerance.Epsilon)
+            {
+                var angle1 = StartAngle;
+                var angle2 = EndAngle;
 
-            // switch the angle to counter clockwise.
-            if (IsReversed)
-                Generic.Swap(ref angle1, ref angle2);
+                if (IsReversed)
+                    Generic.Swap(ref angle1, ref angle2);
 
-            if (Angle.IsBetweenRad(Angle.HalfPI, angle1, angle2))
-                maxY = Center.Y + Radius;
+                if (Angle.IsBetweenRad(Angle.HalfPI, angle1, angle2))
+                    maxY = Center.Y + Radius;
 
-            if (Angle.IsBetweenRad(System.Math.PI, angle1, angle2))
-                minX = Center.X - Radius;
+                if (Angle.IsBetweenRad(System.Math.PI, angle1, angle2))
+                    minX = Center.X - Radius;
 
-            const double oneHalfPI = System.Math.PI * 1.5;
+                const double oneHalfPI = System.Math.PI * 1.5;
 
-            if (Angle.IsBetweenRad(oneHalfPI, angle1, angle2))
-                minY = Center.Y - Radius;
+                if (Angle.IsBetweenRad(oneHalfPI, angle1, angle2))
+                    minY = Center.Y - Radius;
 
-            if (Angle.IsBetweenRad(Angle.TwoPI, angle1, angle2))
-                maxX = Center.X + Radius;
+                if (Angle.IsBetweenRad(Angle.TwoPI, angle1, angle2))
+                    maxX = Center.X + Radius;
+            }
 
             boundingBox.X = minX;
             boundingBox.Y = minY;

OpenNest.Core/Geometry/Box.cs

@@ -1,8 +1,9 @@
-using OpenNest.Math;
+using System;
+using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {
-    public class Box
+    public class Box : IComparable<Box>
     {
         public static readonly Box Empty = new Box();
 
@@ -214,5 +215,19 @@ namespace OpenNest.Geometry
         {
             return string.Format("[Box: X={0}, Y={1}, Width={2}, Length={3}]", X, Y, Width, Length);
         }
+
+        public int CompareTo(Box other)
+        {
+            var cmp = Width.CompareTo(other.Width);
+            return cmp != 0 ? cmp : Length.CompareTo(other.Length);
+        }
+
+        public static bool operator >(Box a, Box b) => a.CompareTo(b) > 0;
+
+        public static bool operator <(Box a, Box b) => a.CompareTo(b) < 0;
+
+        public static bool operator >=(Box a, Box b) => a.CompareTo(b) >= 0;
+
+        public static bool operator <=(Box a, Box b) => a.CompareTo(b) <= 0;
     }
 }

OpenNest.Core/Geometry/Circle.cs

@@ -165,6 +165,13 @@ namespace OpenNest.Geometry
             get { return Circumference(); }
         }
 
+        public override Entity Clone()
+        {
+            var copy = new Circle(center, radius) { Rotation = Rotation };
+            CopyBaseTo(copy);
+            return copy;
+        }
+
         /// <summary>
         /// Reverses the rotation direction.
         /// </summary>

OpenNest.Core/Geometry/EllipseConverter.cs

@@ -173,7 +173,11 @@ namespace OpenNest.Geometry
 
             if (maxDev <= tolerance)
             {
-                results.Add(CreateArc(arcCenter, radius, center, semiMajor, semiMinor, rotation, t0, t1));
+                var arc = CreateArc(arcCenter, radius, center, semiMajor, semiMinor, rotation, t0, t1);
+                if (arc.SweepAngle() < Tolerance.Epsilon)
+                    results.Add(new Line(p0, p1));
+                else
+                    results.Add(arc);
             }
             else
             {

OpenNest.Core/Geometry/Entity.cs

@@ -251,6 +251,23 @@ namespace OpenNest.Geometry
         /// <returns></returns>
         public abstract bool Intersects(Shape shape, out List<Vector> pts);
 
+        /// <summary>
+        /// Creates a deep copy of the entity with a new Id.
+        /// </summary>
+        public abstract Entity Clone();
+
+        /// <summary>
+        /// Copies common Entity properties from this instance to the target.
+        /// </summary>
+        protected void CopyBaseTo(Entity target)
+        {
+            target.Color = Color;
+            target.Layer = Layer;
+            target.LineTypeName = LineTypeName;
+            target.IsVisible = IsVisible;
+            target.Tag = Tag;
+        }
+
         /// <summary>
         /// Type of entity.
         /// </summary>
@@ -259,6 +276,14 @@ namespace OpenNest.Geometry
 
     public static class EntityExtensions
     {
+        public static List<Entity> CloneAll(this IEnumerable<Entity> entities)
+        {
+            var result = new List<Entity>();
+            foreach (var e in entities)
+                result.Add(e.Clone());
+            return result;
+        }
+
         public static List<Vector> CollectPoints(this IEnumerable<Entity> entities)
         {
             var points = new List<Vector>();

OpenNest.Core/Geometry/GeometryOptimizer.cs

@@ -17,6 +17,38 @@ namespace OpenNest.Geometry
                 (list, item, i) => list.GetCollinearLines(item, i),
                 (Line a, Line b, out Line joined) => TryJoinLines(a, b, out joined));
 
+        public static void Deduplicate(IList<Circle> circles)
+        {
+            for (var i = circles.Count - 1; i >= 1; i--)
+            {
+                for (var j = i - 1; j >= 0; j--)
+                {
+                    if (circles[i].Center.DistanceTo(circles[j].Center) <= Tolerance.Epsilon
+                        && circles[i].Radius.IsEqualTo(circles[j].Radius))
+                    {
+                        circles.RemoveAt(i);
+                        break;
+                    }
+                }
+            }
+        }
+
+        public static void Deduplicate(IList<Circle> circles, IList<Arc> arcs)
+        {
+            for (var i = circles.Count - 1; i >= 0; i--)
+            {
+                for (var j = arcs.Count - 1; j >= 0; j--)
+                {
+                    if (arcs[j].Center.DistanceTo(circles[i].Center) <= Tolerance.Epsilon
+                        && arcs[j].Radius.IsEqualTo(circles[i].Radius)
+                        && arcs[j].IsFullCircle())
+                    {
+                        arcs.RemoveAt(j);
+                    }
+                }
+            }
+        }
+
         private delegate bool TryJoin<T>(T a, T b, out T joined);
 
         private static void MergePass<T>(IList<T> items,

OpenNest.Core/Geometry/Line.cs

@@ -257,6 +257,13 @@ namespace OpenNest.Geometry
             }
         }
 
+        public override Entity Clone()
+        {
+            var copy = new Line(pt1, pt2);
+            CopyBaseTo(copy);
+            return copy;
+        }
+
         /// <summary>
         /// Reversed the line.
         /// </summary>

OpenNest.Core/Geometry/Polygon.cs

@@ -168,6 +168,13 @@ namespace OpenNest.Geometry
             get { return Perimeter(); }
         }
 
+        public override Entity Clone()
+        {
+            var copy = new Polygon { Vertices = new List<Vector>(Vertices) };
+            CopyBaseTo(copy);
+            return copy;
+        }
+
         /// <summary>
         /// Reverses the rotation direction of the polygon.
         /// </summary>

OpenNest.Core/Geometry/Shape.cs

@@ -349,6 +349,15 @@ namespace OpenNest.Geometry
             return polygon;
         }
 
+        public override Entity Clone()
+        {
+            var copy = new Shape();
+            foreach (var e in Entities)
+                copy.Entities.Add(e.Clone());
+            CopyBaseTo(copy);
+            return copy;
+        }
+
         /// <summary>
         /// Reverses the rotation direction of the shape.
         /// </summary>

OpenNest.Core/Geometry/ShapeBuilder.cs

@@ -1,12 +1,13 @@
 using OpenNest.Math;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 
 namespace OpenNest.Geometry
 {
     public static class ShapeBuilder
     {
-        public static List<Shape> GetShapes(IEnumerable<Entity> entities)
+        public static List<Shape> GetShapes(IEnumerable<Entity> entities, double? weldTolerance = null)
         {
             var lines = new List<Line>();
             var arcs = new List<Arc>();
@@ -57,6 +58,9 @@ namespace OpenNest.Geometry
             entityList.AddRange(lines);
             entityList.AddRange(arcs);
 
+            if (weldTolerance.HasValue)
+                WeldEndpoints(entityList, weldTolerance.Value);
+
             while (entityList.Count > 0)
             {
                 var next = entityList[0];
@@ -107,6 +111,93 @@ namespace OpenNest.Geometry
             return shapes;
         }
 
+        public static void WeldEndpoints(List<Entity> entities, double tolerance)
+        {
+            var endpointGroups = new List<List<(Entity entity, bool isStart, Vector point)>>();
+
+            foreach (var entity in entities)
+            {
+                var (start, end) = GetEndpoints(entity);
+                if (!start.IsValid() || !end.IsValid())
+                    continue;
+
+                AddToGroup(endpointGroups, entity, true, start, tolerance);
+                AddToGroup(endpointGroups, entity, false, end, tolerance);
+            }
+
+            foreach (var group in endpointGroups)
+            {
+                if (group.Count <= 1)
+                    continue;
+
+                var avgX = group.Average(g => g.point.X);
+                var avgY = group.Average(g => g.point.Y);
+                var weldedPoint = new Vector(avgX, avgY);
+
+                foreach (var (entity, isStart, _) in group)
+                    ApplyWeld(entity, isStart, weldedPoint);
+            }
+        }
+
+        private static void AddToGroup(
+            List<List<(Entity entity, bool isStart, Vector point)>> groups,
+            Entity entity, bool isStart, Vector point, double tolerance)
+        {
+            foreach (var group in groups)
+            {
+                if (group[0].point.DistanceTo(point) <= tolerance)
+                {
+                    group.Add((entity, isStart, point));
+                    return;
+                }
+            }
+
+            groups.Add(new List<(Entity, bool, Vector)> { (entity, isStart, point) });
+        }
+
+        private static (Vector start, Vector end) GetEndpoints(Entity entity)
+        {
+            switch (entity.Type)
+            {
+                case EntityType.Arc:
+                    var arc = (Arc)entity;
+                    return (arc.StartPoint(), arc.EndPoint());
+
+                case EntityType.Line:
+                    var line = (Line)entity;
+                    return (line.StartPoint, line.EndPoint);
+
+                default:
+                    return (Vector.Invalid, Vector.Invalid);
+            }
+        }
+
+        private static void ApplyWeld(Entity entity, bool isStart, Vector weldedPoint)
+        {
+            switch (entity.Type)
+            {
+                case EntityType.Line:
+                    var line = (Line)entity;
+                    if (isStart)
+                        line.StartPoint = weldedPoint;
+                    else
+                        line.EndPoint = weldedPoint;
+                    break;
+
+                case EntityType.Arc:
+                    var arc = (Arc)entity;
+                    var deltaX = weldedPoint.X - arc.Center.X;
+                    var deltaY = weldedPoint.Y - arc.Center.Y;
+                    var angle = System.Math.Atan2(deltaY, deltaX);
+
+                    if (isStart)
+                        arc.StartAngle = angle;
+                    else
+                        arc.EndAngle = angle;
+                    break;
+            }
+        }
+
         internal static Entity GetConnected(Vector pt, IEnumerable<Entity> geometry)
         {
             var tol = Tolerance.ChainTolerance;

OpenNest.Core/Geometry/ShapeProfile.cs

@@ -75,7 +75,8 @@ namespace OpenNest.Geometry
         /// </summary>
         public static List<Entity> NormalizeEntities(IEnumerable<Entity> entities)
         {
-            var profile = new ShapeProfile(entities.ToList());
+            var cloned = entities.CloneAll();
+            var profile = new ShapeProfile(cloned);
             return profile.ToNormalizedEntities();
         }
 

OpenNest.Core/Geometry/SpatialQuery.cs

@@ -306,49 +306,38 @@ namespace OpenNest.Geometry
             var minDist = double.MaxValue;
             var vx = vertex.X;
             var vy = vertex.Y;
+            var horizontal = IsHorizontalDirection(direction);
 
-            // Pruning: edges are sorted by their perpendicular min-coordinate in PartBoundary.
-            if (direction == PushDirection.Left || direction == PushDirection.Right)
+            // Pruning: edges are sorted by their perpendicular min-coordinate.
+            // For horizontal push, prune by Y range; for vertical push, prune by X range.
+            for (var i = 0; i < edges.Length; i++)
             {
-                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)
                 {
-                    var e1 = edges[i].start + edgeOffset;
-                    var e2 = edges[i].end + edgeOffset;
-
-                    var minY = e1.Y < e2.Y ? e1.Y : e2.Y;
-                    var maxY = e1.Y > e2.Y ? e1.Y : e2.Y;
-
-                    // Since edges are sorted by minY, if vy < minY, then vy < all subsequent minY.
-                    if (vy < minY - Tolerance.Epsilon)
-                        break;
-
-                    if (vy > maxY + Tolerance.Epsilon)
-                        continue;
-
-                    var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction);
-                    if (d < minDist) minDist = d;
+                    perpValue = vy;
+                    edgeMin = e1.Y < e2.Y ? e1.Y : e2.Y;
+                    edgeMax = e1.Y > e2.Y ? e1.Y : e2.Y;
                 }
-            }
-            else // Up/Down
-            {
-                for (var i = 0; i < edges.Length; i++)
+                else
                 {
-                    var e1 = edges[i].start + edgeOffset;
-                    var e2 = edges[i].end + edgeOffset;
-
-                    var minX = e1.X < e2.X ? e1.X : e2.X;
-                    var maxX = e1.X > e2.X ? e1.X : e2.X;
-
-                    // Since edges are sorted by minX, if vx < minX, then vx < all subsequent minX.
-                    if (vx < minX - Tolerance.Epsilon)
-                        break;
-
-                    if (vx > maxX + Tolerance.Epsilon)
-                        continue;
-
-                    var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction);
-                    if (d < minDist) minDist = d;
+                    perpValue = vx;
+                    edgeMin = e1.X < e2.X ? e1.X : e2.X;
+                    edgeMax = e1.X > e2.X ? e1.X : e2.X;
                 }
+
+                // Since edges are sorted by edgeMin, if perpValue < edgeMin, all subsequent edges are also past.
+                if (perpValue < edgeMin - Tolerance.Epsilon)
+                    break;
+
+                if (perpValue > edgeMax + Tolerance.Epsilon)
+                    continue;
+
+                var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction);
+                if (d < minDist) minDist = d;
             }
 
             return minDist;
@@ -642,19 +631,46 @@ namespace OpenNest.Geometry
         {
             for (var i = 0; i < arcEntities.Count; i++)
             {
-                if (arcEntities[i] is Arc arc)
+                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++)
                 {
-                    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++)
                     {
-                        if (lineEntities[j] is Line line)
-                        {
-                            var linePt = line.ClosestPointTo(arc.Center);
-                            var arcPt = arc.ClosestPointTo(linePt);
-                            var d = RayEdgeDistance(arcPt.X, arcPt.Y,
-                                line.pt1.X, line.pt1.Y, line.pt2.X, line.pt2.Y,
-                                dirX, dirY);
-                            if (d < minDist) { minDist = d; if (d <= 0) return 0; }
-                        }
+                        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; }
                     }
                 }
             }

OpenNest.Core/Math/Fraction.cs

@@ -3,7 +3,7 @@ using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 
-namespace OpenNest.IO.Bom
+namespace OpenNest.Math
 {
     public static class Fraction
     {

OpenNest.Core/OpenNest.Core.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net8.0-windows</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <RootNamespace>OpenNest</RootNamespace>
     <AssemblyName>OpenNest.Core</AssemblyName>
   </PropertyGroup>

OpenNest.Core/PartGeometry.cs

@@ -126,20 +126,10 @@ namespace OpenNest
         {
             var result = new List<Entity>(source.Count);
 
-            for (var i = 0; i < source.Count; i++)
+            foreach (var entity in source)
             {
-                var entity = source[i];
-                Entity copy;
-
-                if (entity is Line line)
-                    copy = new Line(line.StartPoint + location, line.EndPoint + location);
-                else if (entity is Arc arc)
-                    copy = new Arc(arc.Center + location, arc.Radius, arc.StartAngle, arc.EndAngle, arc.IsReversed);
-                else if (entity is Circle circle)
-                    copy = new Circle(circle.Center + location, circle.Radius);
-                else
-                    continue;
-
+                var copy = entity.Clone();
+                copy.Offset(location);
                 result.Add(copy);
             }
 

OpenNest.Core/Plate.cs

@@ -1,6 +1,7 @@
 using OpenNest.Collections;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using OpenNest.Shapes;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -548,6 +549,65 @@ namespace OpenNest
                 Rounding.RoundUpToNearest(xExtent, roundingFactor));
         }
 
+        /// <summary>
+        /// Sizes the plate using the <see cref="PlateSizes"/> catalog: small
+        /// layouts snap to an increment, larger ones round up to the next
+        /// standard mill sheet. The plate's long-axis orientation (X vs Y)
+        /// is preserved. Does nothing if the plate has no parts.
+        /// </summary>
+        public PlateSizeResult SnapToStandardSize(PlateSizeOptions options = null)
+        {
+            if (Parts.Count == 0)
+                return default;
+
+            var bounds = Parts.GetBoundingBox();
+
+            // Quadrant-aware extents relative to the plate origin, matching AutoSize.
+            double xExtent;
+            double yExtent;
+
+            switch (Quadrant)
+            {
+                case 1:
+                    xExtent = System.Math.Abs(bounds.Right) + EdgeSpacing.Right;
+                    yExtent = System.Math.Abs(bounds.Top) + EdgeSpacing.Top;
+                    break;
+
+                case 2:
+                    xExtent = System.Math.Abs(bounds.Left) + EdgeSpacing.Left;
+                    yExtent = System.Math.Abs(bounds.Top) + EdgeSpacing.Top;
+                    break;
+
+                case 3:
+                    xExtent = System.Math.Abs(bounds.Left) + EdgeSpacing.Left;
+                    yExtent = System.Math.Abs(bounds.Bottom) + EdgeSpacing.Bottom;
+                    break;
+
+                case 4:
+                    xExtent = System.Math.Abs(bounds.Right) + EdgeSpacing.Right;
+                    yExtent = System.Math.Abs(bounds.Bottom) + EdgeSpacing.Bottom;
+                    break;
+
+                default:
+                    return default;
+            }
+
+            // PlateSizes.Recommend takes (short, long); canonicalize then map
+            // the result back so the plate's long axis stays aligned with the
+            // parts' long axis.
+            var shortDim = System.Math.Min(xExtent, yExtent);
+            var longDim = System.Math.Max(xExtent, yExtent);
+            var result = PlateSizes.Recommend(shortDim, longDim, options);
+
+            // Plate convention: Length = X axis, Width = Y axis.
+            if (xExtent >= yExtent)
+                Size = new Size(result.Width, result.Length);   // X is the long axis
+            else
+                Size = new Size(result.Length, result.Width);   // Y is the long axis
+
+            return result;
+        }
+
         /// <summary>
         /// Gets the area of the top surface of the plate.
         /// </summary>

OpenNest.Core/Shapes/CircleShape.cs

@@ -7,6 +7,8 @@ namespace OpenNest.Shapes
     {
         public double Diameter { get; set; }
 
+        public override string GenerateName() => $"Circle {Dim(Diameter)} Dia";
+
         public override void SetPreviewDefaults()
         {
             Diameter = 8;

OpenNest.Core/Shapes/IsoscelesTriangleShape.cs

@@ -8,6 +8,8 @@ namespace OpenNest.Shapes
         public double Base { get; set; }
         public double Height { get; set; }
 
+        public override string GenerateName() => $"Isosceles Triangle {Dim(Base)}x{Dim(Height)}";
+
         public override void SetPreviewDefaults()
         {
             Base = 8;

OpenNest.Core/Shapes/LShape.cs

@@ -10,6 +10,8 @@ namespace OpenNest.Shapes
         public double LegWidth { get; set; }
         public double LegHeight { get; set; }
 
+        public override string GenerateName() => $"L {Dim(Width)}x{Dim(Height)}";
+
         public override void SetPreviewDefaults()
         {
             Width = 8;

OpenNest.Core/Shapes/NgonShape.cs

@@ -3,33 +3,40 @@ using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {
-    public class OctagonShape : ShapeDefinition
+    public class NgonShape : ShapeDefinition
     {
+        public int Sides { get; set; }
         public double Width { get; set; }
 
+        public override string GenerateName() => $"{Sides}-Sided Polygon {Dim(Width)}";
+
         public override void SetPreviewDefaults()
         {
+            Sides = 8;
             Width = 8;
         }
 
         public override Drawing GetDrawing()
         {
+            var n = Sides < 3 ? 3 : Sides;
             var center = Width / 2.0;
-            var circumRadius = Width / (2.0 * System.Math.Cos(System.Math.PI / 8.0));
+            var circumRadius = Width / (2.0 * System.Math.Cos(System.Math.PI / n));
+            var step = 2.0 * System.Math.PI / n;
+            var start = System.Math.PI / n;
 
-            var vertices = new Vector[8];
-            for (var i = 0; i < 8; i++)
+            var vertices = new Vector[n];
+            for (var i = 0; i < n; i++)
             {
-                var angle = System.Math.PI / 8.0 + i * System.Math.PI / 4.0;
+                var angle = start + i * step;
                 vertices[i] = new Vector(
                     center + circumRadius * System.Math.Cos(angle),
                     center + circumRadius * System.Math.Sin(angle));
             }
 
             var entities = new List<Entity>();
-            for (var i = 0; i < 8; i++)
+            for (var i = 0; i < n; i++)
             {
-                var next = (i + 1) % 8;
+                var next = (i + 1) % n;
                 entities.Add(new Line(vertices[i], vertices[next]));
             }
 

OpenNest.Core/Shapes/PipeFlangeShape.cs

@@ -3,31 +3,41 @@ using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {
-    public class FlangeShape : ShapeDefinition
+    public class PipeFlangeShape : ShapeDefinition
     {
-        public double NominalPipeSize { get; set; }
         public double OD { get; set; }
         public double HoleDiameter { get; set; }
         public double HolePatternDiameter { get; set; }
         public int HoleCount { get; set; }
+        public string PipeSize { get; set; }
+        public double PipeClearance { get; set; }
+        public bool Blind { get; set; }
+
+        public override string GenerateName()
+        {
+            var name = $"Pipe Flange {Dim(OD)} OD";
+            if (!string.IsNullOrEmpty(PipeSize))
+                name += $" {PipeSize} Pipe";
+            return name;
+        }
 
         public override void SetPreviewDefaults()
         {
-            NominalPipeSize = 2;
             OD = 7.5;
             HoleDiameter = 0.875;
             HolePatternDiameter = 5.5;
             HoleCount = 8;
+            PipeSize = "2";
+            PipeClearance = 0.0625;
+            Blind = false;
         }
 
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>();
 
-            // Outer circle
             entities.Add(new Circle(0, 0, OD / 2.0));
 
-            // Bolt holes evenly spaced on the bolt circle
             var boltCircleRadius = HolePatternDiameter / 2.0;
             var holeRadius = HoleDiameter / 2.0;
             var angleStep = 2.0 * System.Math.PI / HoleCount;
@@ -40,6 +50,12 @@ namespace OpenNest.Shapes
                 entities.Add(new Circle(cx, cy, holeRadius));
             }
 
+            if (!Blind && !string.IsNullOrEmpty(PipeSize) && PipeSizes.TryGetOD(PipeSize, out var pipeOD))
+            {
+                var boreDiameter = pipeOD + PipeClearance;
+                entities.Add(new Circle(0, 0, boreDiameter / 2.0));
+            }
+
             return CreateDrawing(entities);
         }
     }

OpenNest.Core/Shapes/PipeSizes.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+
+namespace OpenNest.Shapes
+{
+    public static class PipeSizes
+    {
+        public readonly record struct Entry(string Label, double OuterDiameter);
+
+        public static IReadOnlyList<Entry> All { get; } = new[]
+        {
+            new Entry("1/8",    0.405),
+            new Entry("1/4",    0.540),
+            new Entry("3/8",    0.675),
+            new Entry("1/2",    0.840),
+            new Entry("3/4",    1.050),
+            new Entry("1",      1.315),
+            new Entry("1 1/4",  1.660),
+            new Entry("1 1/2",  1.900),
+            new Entry("2",      2.375),
+            new Entry("2 1/2",  2.875),
+            new Entry("3",      3.500),
+            new Entry("3 1/2",  4.000),
+            new Entry("4",      4.500),
+            new Entry("4 1/2",  5.000),
+            new Entry("5",      5.563),
+            new Entry("6",      6.625),
+            new Entry("7",      7.625),
+            new Entry("8",      8.625),
+            new Entry("9",      9.625),
+            new Entry("10",    10.750),
+            new Entry("11",    11.750),
+            new Entry("12",    12.750),
+            new Entry("14",    14.000),
+            new Entry("16",    16.000),
+            new Entry("18",    18.000),
+            new Entry("20",    20.000),
+            new Entry("24",    24.000),
+            new Entry("26",    26.000),
+            new Entry("28",    28.000),
+            new Entry("30",    30.000),
+            new Entry("32",    32.000),
+            new Entry("34",    34.000),
+            new Entry("36",    36.000),
+            new Entry("42",    42.000),
+            new Entry("48",    48.000),
+        };
+
+        public static bool TryGetOD(string label, out double outerDiameter)
+        {
+            foreach (var entry in All)
+            {
+                if (entry.Label == label)
+                {
+                    outerDiameter = entry.OuterDiameter;
+                    return true;
+                }
+            }
+
+            outerDiameter = 0;
+            return false;
+        }
+
+        /// <summary>
+        /// Returns all pipe sizes whose outer diameter is less than or equal to <paramref name="maxOD"/>.
+        /// The bound is inclusive.
+        /// </summary>
+        public static IEnumerable<Entry> GetFittingSizes(double maxOD)
+        {
+            foreach (var entry in All)
+            {
+                if (entry.OuterDiameter <= maxOD)
+                {
+                    yield return entry;
+                }
+            }
+        }
+    }
+}

OpenNest.Core/Shapes/PlateSizes.cs

@@ -0,0 +1,255 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenNest.Geometry;
+
+namespace OpenNest.Shapes
+{
+    /// <summary>
+    /// Catalog of standard mill sheet sizes (inches) with helpers for matching
+    /// a bounding box to a recommended plate size. Uses the project-wide
+    /// (Width, Length) convention where Width is the short dimension and
+    /// Length is the long dimension.
+    /// </summary>
+    public static class PlateSizes
+    {
+        public readonly record struct Entry(string Label, double Width, double Length)
+        {
+            public double Area => Width * Length;
+
+            /// <summary>
+            /// Returns true if a part of the given dimensions fits within this entry
+            /// in either orientation.
+            /// </summary>
+            public bool Fits(double width, double length) =>
+                (width <= Width && length <= Length) || (width <= Length && length <= Width);
+        }
+
+        /// <summary>
+        /// Standard mill sheet sizes (inches), sorted by area ascending.
+        /// Canonical orientation: Width &lt;= Length.
+        /// </summary>
+        public static IReadOnlyList<Entry> All { get; } = new[]
+        {
+            new Entry("48x96",   48,  96),   // 4608
+            new Entry("48x120",  48, 120),   // 5760
+            new Entry("48x144",  48, 144),   // 6912
+            new Entry("60x120",  60, 120),   // 7200
+            new Entry("60x144",  60, 144),   // 8640
+            new Entry("72x120",  72, 120),   // 8640
+            new Entry("72x144",  72, 144),   // 10368
+            new Entry("96x240",  96, 240),   // 23040
+        };
+
+        /// <summary>
+        /// Looks up a standard size by label. Case-insensitive.
+        /// </summary>
+        public static bool TryGet(string label, out Entry entry)
+        {
+            if (!string.IsNullOrWhiteSpace(label))
+            {
+                foreach (var candidate in All)
+                {
+                    if (string.Equals(candidate.Label, label, StringComparison.OrdinalIgnoreCase))
+                    {
+                        entry = candidate;
+                        return true;
+                    }
+                }
+            }
+
+            entry = default;
+            return false;
+        }
+
+        /// <summary>
+        /// Recommends a plate size for the given bounding box. The box's
+        /// spatial axes are normalized to (short, long) so neither the bbox
+        /// orientation nor Box's internal Length/Width naming matters.
+        /// </summary>
+        public static PlateSizeResult Recommend(Box bbox, PlateSizeOptions options = null)
+        {
+            var a = bbox.Width;
+            var b = bbox.Length;
+            return Recommend(System.Math.Min(a, b), System.Math.Max(a, b), options);
+        }
+
+        /// <summary>
+        /// Recommends a plate size for the envelope of the given boxes.
+        /// </summary>
+        public static PlateSizeResult Recommend(IEnumerable<Box> boxes, PlateSizeOptions options = null)
+        {
+            if (boxes == null)
+                throw new ArgumentNullException(nameof(boxes));
+
+            var hasAny = false;
+            var minX = double.PositiveInfinity;
+            var minY = double.PositiveInfinity;
+            var maxX = double.NegativeInfinity;
+            var maxY = double.NegativeInfinity;
+
+            foreach (var box in boxes)
+            {
+                hasAny = true;
+                if (box.Left < minX) minX = box.Left;
+                if (box.Bottom < minY) minY = box.Bottom;
+                if (box.Right > maxX) maxX = box.Right;
+                if (box.Top > maxY) maxY = box.Top;
+            }
+
+            if (!hasAny)
+                throw new ArgumentException("At least one box is required.", nameof(boxes));
+
+            var b = maxX - minX;
+            var a = maxY - minY;
+            return Recommend(System.Math.Min(a, b), System.Math.Max(a, b), options);
+        }
+
+        /// <summary>
+        /// Recommends a plate size for a (width, length) pair.
+        /// Inputs are treated as orientation-independent.
+        /// </summary>
+        public static PlateSizeResult Recommend(double width, double length, PlateSizeOptions options = null)
+        {
+            options ??= new PlateSizeOptions();
+
+            var w = width + 2 * options.Margin;
+            var l = length + 2 * options.Margin;
+
+            // Canonicalize (short, long) — Fits handles rotation anyway, but
+            // normalizing lets the below-min comparison use the narrower
+            // MinSheet dimensions consistently.
+            if (w > l)
+                (w, l) = (l, w);
+
+            // Below full-sheet threshold: snap each dimension up to the nearest increment.
+            if (w <= options.MinSheetWidth && l <= options.MinSheetLength)
+                return SnapResult(w, l, options.SnapIncrement);
+
+            var catalog = BuildCatalog(options.AllowedSizes);
+
+            var best = PickBest(catalog, w, l, options.Selection);
+            if (best.HasValue)
+                return new PlateSizeResult(best.Value.Width, best.Value.Length, best.Value.Label);
+
+            // Nothing in the catalog fits - fall back to snap-up (ad-hoc oversize sheet).
+            return SnapResult(w, l, options.SnapIncrement);
+        }
+
+        private static PlateSizeResult SnapResult(double width, double length, double increment)
+        {
+            if (increment <= 0)
+                return new PlateSizeResult(width, length, null);
+
+            return new PlateSizeResult(SnapUp(width, increment), SnapUp(length, increment), null);
+        }
+
+        private static double SnapUp(double value, double increment)
+        {
+            var steps = System.Math.Ceiling(value / increment);
+            return steps * increment;
+        }
+
+        private static IReadOnlyList<Entry> BuildCatalog(IReadOnlyList<string> allowedSizes)
+        {
+            if (allowedSizes == null || allowedSizes.Count == 0)
+                return All;
+
+            var result = new List<Entry>(allowedSizes.Count);
+            foreach (var label in allowedSizes)
+            {
+                if (TryParseEntry(label, out var entry))
+                    result.Add(entry);
+            }
+
+            return result;
+        }
+
+        private static bool TryParseEntry(string label, out Entry entry)
+        {
+            if (TryGet(label, out entry))
+                return true;
+
+            // Accept ad-hoc "WxL" strings (e.g. "50x100", "50 x 100").
+            if (!string.IsNullOrWhiteSpace(label))
+            {
+                var parts = label.Split(new[] { 'x', 'X' }, 2);
+                if (parts.Length == 2
+                    && double.TryParse(parts[0].Trim(), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var a)
+                    && double.TryParse(parts[1].Trim(), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var b)
+                    && a > 0 && b > 0)
+                {
+                    var width = System.Math.Min(a, b);
+                    var length = System.Math.Max(a, b);
+                    entry = new Entry(label.Trim(), width, length);
+                    return true;
+                }
+            }
+
+            entry = default;
+            return false;
+        }
+
+        private static Entry? PickBest(IReadOnlyList<Entry> catalog, double width, double length, PlateSizeSelection selection)
+        {
+            var fitting = catalog.Where(e => e.Fits(width, length));
+
+            fitting = selection switch
+            {
+                PlateSizeSelection.NarrowestFirst => fitting.OrderBy(e => e.Width).ThenBy(e => e.Area),
+                _ => fitting.OrderBy(e => e.Area).ThenBy(e => e.Width),
+            };
+
+            foreach (var candidate in fitting)
+                return candidate;
+
+            return null;
+        }
+    }
+
+    public readonly record struct PlateSizeResult(double Width, double Length, string MatchedLabel)
+    {
+        public bool IsStandard => MatchedLabel != null;
+    }
+
+    public sealed class PlateSizeOptions
+    {
+        /// <summary>
+        /// If the margin-adjusted bounding box fits within MinSheetWidth x MinSheetLength
+        /// the result is snapped to <see cref="SnapIncrement"/> instead of routed to a
+        /// standard sheet. Default 48" x 48".
+        /// </summary>
+        public double MinSheetWidth { get; set; } = 48;
+        public double MinSheetLength { get; set; } = 48;
+
+        /// <summary>
+        /// Increment used for below-threshold rounding and oversize fallback. Default 1".
+        /// </summary>
+        public double SnapIncrement { get; set; } = 1.0;
+
+        /// <summary>
+        /// Extra clearance added to each side of the bounding box before matching.
+        /// </summary>
+        public double Margin { get; set; } = 0;
+
+        /// <summary>
+        /// Optional whitelist. When non-empty, only these sizes are considered.
+        /// Entries may be standard catalog labels (e.g. "48x96") or arbitrary
+        /// "WxL" strings (e.g. "50x100").
+        /// </summary>
+        public IReadOnlyList<string> AllowedSizes { get; set; }
+
+        /// <summary>
+        /// Tiebreaker when multiple sheets can contain the bounding box.
+        /// </summary>
+        public PlateSizeSelection Selection { get; set; } = PlateSizeSelection.SmallestArea;
+    }
+
+    public enum PlateSizeSelection
+    {
+        /// <summary>Pick the cheapest sheet that contains the bbox (smallest area).</summary>
+        SmallestArea,
+        /// <summary>Prefer narrower-width sheets (e.g. 48-wide before 60-wide).</summary>
+        NarrowestFirst,
+    }
+}

OpenNest.Core/Shapes/RectangleShape.cs

@@ -8,6 +8,8 @@ namespace OpenNest.Shapes
         public double Length { get; set; }
         public double Width { get; set; }
 
+        public override string GenerateName() => $"Rectangle {Dim(Length)}x{Dim(Width)}";
+
         public override void SetPreviewDefaults()
         {
             Length = 12;

OpenNest.Core/Shapes/RightTriangleShape.cs

@@ -8,6 +8,8 @@ namespace OpenNest.Shapes
         public double Width { get; set; }
         public double Height { get; set; }
 
+        public override string GenerateName() => $"Right Triangle {Dim(Width)}x{Dim(Height)}";
+
         public override void SetPreviewDefaults()
         {
             Width = 8;

OpenNest.Core/Shapes/RingShape.cs

@@ -8,6 +8,8 @@ namespace OpenNest.Shapes
         public double OuterDiameter { get; set; }
         public double InnerDiameter { get; set; }
 
+        public override string GenerateName() => $"Ring {Dim(OuterDiameter)}x{Dim(InnerDiameter)}";
+
         public override void SetPreviewDefaults()
         {
             OuterDiameter = 10;

OpenNest.Core/Shapes/RoundedRectangleShape.cs

@@ -10,6 +10,8 @@ namespace OpenNest.Shapes
         public double Width { get; set; }
         public double Radius { get; set; }
 
+        public override string GenerateName() => $"Rounded Rectangle {Dim(Length)}x{Dim(Width)} R{Dim(Radius)}";
+
         public override void SetPreviewDefaults()
         {
             Length = 12;

OpenNest.Core/Shapes/ShapeDefinition.cs

@@ -26,6 +26,14 @@ namespace OpenNest.Shapes
 
         public abstract Drawing GetDrawing();
 
+        public virtual string GenerateName()
+        {
+            var typeName = GetType().Name;
+            return typeName.EndsWith("Shape")
+                ? typeName.Substring(0, typeName.Length - 5)
+                : typeName;
+        }
+
         public virtual void SetPreviewDefaults() { }
 
         public static List<T> LoadFromJson<T>(string path) where T : ShapeDefinition
@@ -34,6 +42,8 @@ namespace OpenNest.Shapes
             return JsonSerializer.Deserialize<List<T>>(json, JsonOptions);
         }
 
+        protected static string Dim(double value) => value.ToString("0.###");
+
         protected Drawing CreateDrawing(List<Entity> entities)
         {
             var pgm = ConvertGeometry.ToProgram(entities);

OpenNest.Core/Shapes/TShape.cs

@@ -10,6 +10,8 @@ namespace OpenNest.Shapes
         public double StemWidth { get; set; }
         public double BarHeight { get; set; }
 
+        public override string GenerateName() => $"T {Dim(Width)}x{Dim(Height)}";
+
         public override void SetPreviewDefaults()
         {
             Width = 10;

OpenNest.Core/Shapes/TrapezoidShape.cs

@@ -9,6 +9,8 @@ namespace OpenNest.Shapes
         public double BottomWidth { get; set; }
         public double Height { get; set; }
 
+        public override string GenerateName() => $"Trapezoid {Dim(TopWidth)}x{Dim(BottomWidth)}x{Dim(Height)}";
+
         public override void SetPreviewDefaults()
         {
             TopWidth = 6;

OpenNest.Core/Splitting/DrawingSplitter.cs

@@ -32,12 +32,20 @@ public static class DrawingSplitter
         var regions = BuildClipRegions(sortedLines, bounds);
         var feature = GetFeature(parameters.Type);
 
+        // Polygonize cutouts once. Used for trimming feature edges (so cut lines
+        // don't travel through a cutout interior) and for hole/containment tests
+        // in the final component-assembly pass.
+        var cutoutPolygons = profile.Cutouts
+            .Select(c => c.ToPolygon())
+            .Where(p => p != null)
+            .ToList();
+
         var results = new List<Drawing>();
         var pieceIndex = 1;
 
         foreach (var region in regions)
         {
-            var pieceEntities = ClipPerimeterToRegion(perimeter, region, sortedLines, feature, parameters);
+            var pieceEntities = ClipPerimeterToRegion(perimeter, region, sortedLines, feature, parameters, cutoutPolygons);
             if (pieceEntities.Count == 0)
                 continue;
 
@@ -47,9 +55,16 @@ public static class DrawingSplitter
             allEntities.AddRange(pieceEntities);
             allEntities.AddRange(cutoutEntities);
 
-            var piece = BuildPieceDrawing(drawing, allEntities, pieceIndex, region);
-            results.Add(piece);
-            pieceIndex++;
+            // A single region may yield multiple physically-disjoint pieces when an
+            // interior cutout spans across it. Group the region's entities into
+            // connected closed loops, nest holes by containment, and emit one
+            // Drawing per outer loop (with its contained holes).
+            foreach (var pieceOfRegion in AssemblePieces(allEntities))
+            {
+                var piece = BuildPieceDrawing(drawing, pieceOfRegion, pieceIndex, region);
+                results.Add(piece);
+                pieceIndex++;
+            }
         }
 
         return results;
@@ -218,100 +233,108 @@ public static class DrawingSplitter
     /// and stitching in feature edges. No polygon clipping library needed.
     /// </summary>
     private static List<Entity> ClipPerimeterToRegion(Shape perimeter, Box region,
-        List<SplitLine> splitLines, ISplitFeature feature, SplitParameters parameters)
+        List<SplitLine> splitLines, ISplitFeature feature, SplitParameters parameters,
+        List<Polygon> cutoutPolygons)
     {
         var boundarySplitLines = GetBoundarySplitLines(region, splitLines);
         var entities = new List<Entity>();
-        var splitPoints = new List<(Vector Point, SplitLine Line, bool IsExit)>();
 
         foreach (var entity in perimeter.Entities)
-        {
-            ProcessEntity(entity, region, boundarySplitLines, entities, splitPoints);
-        }
+            ProcessEntity(entity, region, entities);
 
         if (entities.Count == 0)
             return new List<Entity>();
 
-        InsertFeatureEdges(entities, splitPoints, region, boundarySplitLines, feature, parameters);
-        EnsurePerimeterWinding(entities);
+        InsertFeatureEdges(entities, region, boundarySplitLines, feature, parameters, cutoutPolygons);
+        // Winding is handled later in AssemblePieces, once connected components
+        // are known. At this stage the piece may still be multiple disjoint loops.
         return entities;
     }
 
-    private static void ProcessEntity(Entity entity, Box region,
-        List<SplitLine> boundarySplitLines, List<Entity> entities,
-        List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints)
-    {
-        // Find the first boundary split line this entity crosses
-        SplitLine crossedLine = null;
-        Vector? intersectionPt = null;
-
-        foreach (var sl in boundarySplitLines)
-        {
-            if (SplitLineIntersect.CrossesSplitLine(entity, sl))
-            {
-                var pt = SplitLineIntersect.FindIntersection(entity, sl);
-                if (pt != null)
-                {
-                    crossedLine = sl;
-                    intersectionPt = pt;
-                    break;
-                }
-            }
-        }
-
-        if (crossedLine != null)
-        {
-            // Entity crosses a split line — split it and keep the half inside the region
-            var regionSide = RegionSideOf(region, crossedLine);
-            var startPt = GetStartPoint(entity);
-            var startSide = SplitLineIntersect.SideOf(startPt, crossedLine);
-            var startInRegion = startSide == regionSide || startSide == 0;
-
-            SplitEntityAtPoint(entity, intersectionPt.Value, startInRegion, crossedLine, entities, splitPoints);
-        }
-        else
-        {
-            // Entity doesn't cross any boundary split line — check if it's inside the region
-            var mid = MidPoint(entity);
-            if (region.Contains(mid))
-                entities.Add(entity);
-        }
-    }
-
-    private static void SplitEntityAtPoint(Entity entity, Vector point, bool startInRegion,
-        SplitLine crossedLine, List<Entity> entities,
-        List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints)
+    private static void ProcessEntity(Entity entity, Box region, List<Entity> entities)
     {
         if (entity is Line line)
         {
-            var (first, second) = line.SplitAt(point);
-            if (startInRegion)
-            {
-                if (first != null) entities.Add(first);
-                splitPoints.Add((point, crossedLine, true));
-            }
-            else
-            {
-                splitPoints.Add((point, crossedLine, false));
-                if (second != null) entities.Add(second);
-            }
+            var clipped = ClipLineToBox(line.StartPoint, line.EndPoint, region);
+            if (clipped == null) return;
+            if (clipped.Value.Start.DistanceTo(clipped.Value.End) < Math.Tolerance.Epsilon) return;
+            entities.Add(new Line(clipped.Value.Start, clipped.Value.End));
+            return;
         }
-        else if (entity is Arc arc)
+
+        if (entity is Arc arc)
         {
-            var (first, second) = arc.SplitAt(point);
-            if (startInRegion)
-            {
-                if (first != null) entities.Add(first);
-                splitPoints.Add((point, crossedLine, true));
-            }
-            else
-            {
-                splitPoints.Add((point, crossedLine, false));
-                if (second != null) entities.Add(second);
-            }
+            foreach (var sub in ClipArcToRegion(arc, region))
+                entities.Add(sub);
+            return;
         }
     }
 
+    /// <summary>
+    /// Clips an arc against the four edges of a region box. Returns the sub-arcs
+    /// whose midpoints lie inside the region. Uses line-arc intersection to find
+    /// split points, then iteratively bisects the arc at each crossing.
+    /// </summary>
+    private static List<Arc> ClipArcToRegion(Arc arc, Box region)
+    {
+        var edges = new[]
+        {
+            new Line(new Vector(region.Left, region.Bottom), new Vector(region.Right, region.Bottom)),
+            new Line(new Vector(region.Right, region.Bottom), new Vector(region.Right, region.Top)),
+            new Line(new Vector(region.Right, region.Top), new Vector(region.Left, region.Top)),
+            new Line(new Vector(region.Left, region.Top), new Vector(region.Left, region.Bottom))
+        };
+
+        var arcs = new List<Arc> { arc };
+
+        foreach (var edge in edges)
+        {
+            var next = new List<Arc>();
+            foreach (var a in arcs)
+            {
+                if (!Intersect.Intersects(a, edge, out var pts) || pts.Count == 0)
+                {
+                    next.Add(a);
+                    continue;
+                }
+
+                // Split the arc at each intersection that actually lies on one of
+                // the working sub-arcs. Prior splits may make some original hits
+                // moot for the sub-arc that now holds them.
+                var working = new List<Arc> { a };
+                foreach (var pt in pts)
+                {
+                    var replaced = new List<Arc>();
+                    foreach (var w in working)
+                    {
+                        var onArc = OpenNest.Math.Angle.IsBetweenRad(
+                            w.Center.AngleTo(pt), w.StartAngle, w.EndAngle, w.IsReversed);
+                        if (!onArc)
+                        {
+                            replaced.Add(w);
+                            continue;
+                        }
+
+                        var (first, second) = w.SplitAt(pt);
+                        if (first != null && first.SweepAngle() > Math.Tolerance.Epsilon) replaced.Add(first);
+                        if (second != null && second.SweepAngle() > Math.Tolerance.Epsilon) replaced.Add(second);
+                    }
+                    working = replaced;
+                }
+                next.AddRange(working);
+            }
+            arcs = next;
+        }
+
+        var result = new List<Arc>();
+        foreach (var a in arcs)
+        {
+            if (region.Contains(a.MidPoint()))
+                result.Add(a);
+        }
+        return result;
+    }
+
     /// <summary>
     /// Returns split lines whose position matches a boundary edge of the region.
     /// </summary>
@@ -365,104 +388,157 @@ public static class DrawingSplitter
     }
 
     /// <summary>
-    /// Groups split points by split line, pairs exits with entries, and generates feature edges.
+    /// For each boundary split line of the region, generates a feature edge that
+    /// spans the full region boundary along that split line and trims it against
+    /// interior cutouts. This produces one (or zero) feature edge per contiguous
+    /// material interval on the boundary, handling corner regions (one perimeter
+    /// crossing), spanning cutouts (two holes puncturing the line), and
+    /// normal mid-part splits uniformly.
     /// </summary>
     private static void InsertFeatureEdges(List<Entity> entities,
-        List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints,
         Box region, List<SplitLine> boundarySplitLines,
-        ISplitFeature feature, SplitParameters parameters)
+        ISplitFeature feature, SplitParameters parameters,
+        List<Polygon> cutoutPolygons)
     {
-        // Group split points by their split line
-        var groups = new Dictionary<SplitLine, List<(Vector Point, bool IsExit)>>();
-        foreach (var sp in splitPoints)
+        foreach (var sl in boundarySplitLines)
         {
-            if (!groups.ContainsKey(sp.Line))
-                groups[sp.Line] = new List<(Vector, bool)>();
-            groups[sp.Line].Add((sp.Point, sp.IsExit));
-        }
+            var isVertical = sl.Axis == CutOffAxis.Vertical;
+            var extentStart = isVertical ? region.Bottom : region.Left;
+            var extentEnd = isVertical ? region.Top : region.Right;
 
-        foreach (var kvp in groups)
-        {
-            var sl = kvp.Key;
-            var points = kvp.Value;
-
-            // Pair each exit with the next entry
-            var exits = points.Where(p => p.IsExit).Select(p => p.Point).ToList();
-            var entries = points.Where(p => !p.IsExit).Select(p => p.Point).ToList();
-
-            if (exits.Count == 0 || entries.Count == 0)
+            if (extentEnd - extentStart < Math.Tolerance.Epsilon)
                 continue;
 
-            // For each exit, find the matching entry to form the feature edge span
-            // Sort exits and entries by their position along the split line
-            var isVertical = sl.Axis == CutOffAxis.Vertical;
-            exits = exits.OrderBy(p => isVertical ? p.Y : p.X).ToList();
-            entries = entries.OrderBy(p => isVertical ? p.Y : p.X).ToList();
+            var featureResult = feature.GenerateFeatures(sl, extentStart, extentEnd, parameters);
+            var isNegativeSide = RegionSideOf(region, sl) < 0;
+            var featureEdge = isNegativeSide ? featureResult.NegativeSideEdge : featureResult.PositiveSideEdge;
 
-            // Pair them up: each exit with the next entry (or vice versa)
-            var pairCount = System.Math.Min(exits.Count, entries.Count);
-            for (var i = 0; i < pairCount; i++)
+            // Trim any line segments that cross a cutout — cut lines must never
+            // travel through a hole.
+            featureEdge = TrimFeatureEdgeAgainstCutouts(featureEdge, cutoutPolygons);
+
+            entities.AddRange(featureEdge);
+        }
+    }
+
+    /// <summary>
+    /// Subtracts any portions of line entities in <paramref name="featureEdge"/> that
+    /// lie inside any of the supplied cutout polygons. Non-line entities (arcs) are
+    /// passed through unchanged; a tighter fix for arcs in feature edges (weld-gap
+    /// tabs, spike-groove) can be added later if a test demands it.
+    /// </summary>
+    private static List<Entity> TrimFeatureEdgeAgainstCutouts(List<Entity> featureEdge, List<Polygon> cutoutPolygons)
+    {
+        if (cutoutPolygons.Count == 0 || featureEdge.Count == 0)
+            return featureEdge;
+
+        var result = new List<Entity>();
+        foreach (var entity in featureEdge)
+        {
+            if (entity is Line line)
+                result.AddRange(SubtractCutoutsFromLine(line, cutoutPolygons));
+            else
+                result.Add(entity);
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Returns the sub-segments of <paramref name="line"/> that lie outside every
+    /// cutout polygon. Handles the common axis-aligned feature-edge case exactly.
+    /// </summary>
+    private static List<Line> SubtractCutoutsFromLine(Line line, List<Polygon> cutoutPolygons)
+    {
+        // Collect parameter values t in [0,1] where the line crosses any cutout edge.
+        var ts = new List<double> { 0.0, 1.0 };
+        foreach (var poly in cutoutPolygons)
+        {
+            var polyLines = poly.ToLines();
+            foreach (var edge in polyLines)
             {
-                var exitPt = exits[i];
-                var entryPt = entries[i];
-
-                var extentStart = isVertical
-                    ? System.Math.Min(exitPt.Y, entryPt.Y)
-                    : System.Math.Min(exitPt.X, entryPt.X);
-                var extentEnd = isVertical
-                    ? System.Math.Max(exitPt.Y, entryPt.Y)
-                    : System.Math.Max(exitPt.X, entryPt.X);
-
-                var featureResult = feature.GenerateFeatures(sl, extentStart, extentEnd, parameters);
-
-                var isNegativeSide = RegionSideOf(region, sl) < 0;
-                var featureEdge = isNegativeSide ? featureResult.NegativeSideEdge : featureResult.PositiveSideEdge;
-
-                if (featureEdge.Count > 0)
-                    featureEdge = AlignFeatureDirection(featureEdge, exitPt, entryPt, sl.Axis);
-
-                entities.AddRange(featureEdge);
+                if (TryIntersectSegments(line.StartPoint, line.EndPoint, edge.StartPoint, edge.EndPoint, out var t))
+                {
+                    if (t > Math.Tolerance.Epsilon && t < 1.0 - Math.Tolerance.Epsilon)
+                        ts.Add(t);
+                }
             }
         }
-    }
 
-    private static List<Entity> AlignFeatureDirection(List<Entity> featureEdge, Vector start, Vector end, CutOffAxis axis)
-    {
-        var featureStart = GetStartPoint(featureEdge[0]);
-        var featureEnd = GetEndPoint(featureEdge[^1]);
-        var isVertical = axis == CutOffAxis.Vertical;
+        ts.Sort();
 
-        var edgeGoesForward = isVertical ? start.Y < end.Y : start.X < end.X;
-        var featureGoesForward = isVertical ? featureStart.Y < featureEnd.Y : featureStart.X < featureEnd.X;
-
-        if (edgeGoesForward != featureGoesForward)
+        var segments = new List<Line>();
+        for (var i = 0; i < ts.Count - 1; i++)
         {
-            featureEdge = new List<Entity>(featureEdge);
-            featureEdge.Reverse();
-            foreach (var e in featureEdge)
-                e.Reverse();
+            var t0 = ts[i];
+            var t1 = ts[i + 1];
+            if (t1 - t0 < Math.Tolerance.Epsilon) continue;
+
+            var tMid = (t0 + t1) * 0.5;
+            var mid = new Vector(
+                line.StartPoint.X + (line.EndPoint.X - line.StartPoint.X) * tMid,
+                line.StartPoint.Y + (line.EndPoint.Y - line.StartPoint.Y) * tMid);
+
+            var insideCutout = false;
+            foreach (var poly in cutoutPolygons)
+            {
+                if (poly.ContainsPoint(mid))
+                {
+                    insideCutout = true;
+                    break;
+                }
+            }
+            if (insideCutout) continue;
+
+            var p0 = new Vector(
+                line.StartPoint.X + (line.EndPoint.X - line.StartPoint.X) * t0,
+                line.StartPoint.Y + (line.EndPoint.Y - line.StartPoint.Y) * t0);
+            var p1 = new Vector(
+                line.StartPoint.X + (line.EndPoint.X - line.StartPoint.X) * t1,
+                line.StartPoint.Y + (line.EndPoint.Y - line.StartPoint.Y) * t1);
+
+            segments.Add(new Line(p0, p1));
         }
 
-        return featureEdge;
+        return segments;
     }
 
-    private static void EnsurePerimeterWinding(List<Entity> entities)
+    /// <summary>
+    /// Segment-segment intersection. On hit, returns the parameter t along segment AB
+    /// (0 = a0, 1 = a1) via <paramref name="tOnA"/>.
+    /// </summary>
+    private static bool TryIntersectSegments(Vector a0, Vector a1, Vector b0, Vector b1, out double tOnA)
     {
-        var shape = new Shape();
-        shape.Entities.AddRange(entities);
-        var poly = shape.ToPolygon();
-        if (poly != null && poly.RotationDirection() != RotationType.CW)
-            shape.Reverse();
+        tOnA = 0;
+        var rx = a1.X - a0.X;
+        var ry = a1.Y - a0.Y;
+        var sx = b1.X - b0.X;
+        var sy = b1.Y - b0.Y;
 
-        entities.Clear();
-        entities.AddRange(shape.Entities);
+        var denom = rx * sy - ry * sx;
+        if (System.Math.Abs(denom) < Math.Tolerance.Epsilon)
+            return false;
+
+        var dx = b0.X - a0.X;
+        var dy = b0.Y - a0.Y;
+        var t = (dx * sy - dy * sx) / denom;
+        var u = (dx * ry - dy * rx) / denom;
+
+        if (t < -Math.Tolerance.Epsilon || t > 1 + Math.Tolerance.Epsilon) return false;
+        if (u < -Math.Tolerance.Epsilon || u > 1 + Math.Tolerance.Epsilon) return false;
+
+        tOnA = t;
+        return true;
     }
 
     private static bool IsCutoutInRegion(Shape cutout, Box region)
     {
         if (cutout.Entities.Count == 0) return false;
-        var pt = GetStartPoint(cutout.Entities[0]);
-        return region.Contains(pt);
+        var bb = cutout.BoundingBox;
+        // Fully contained iff the cutout's bounding box fits inside the region.
+        return bb.Left >= region.Left - Math.Tolerance.Epsilon
+            && bb.Right <= region.Right + Math.Tolerance.Epsilon
+            && bb.Bottom >= region.Bottom - Math.Tolerance.Epsilon
+            && bb.Top <= region.Top + Math.Tolerance.Epsilon;
     }
 
     private static bool DoesCutoutCrossSplitLine(Shape cutout, List<SplitLine> splitLines)
@@ -479,57 +555,135 @@ public static class DrawingSplitter
     }
 
     /// <summary>
-    /// Clip a cutout shape to a region by walking entities, splitting at split line
-    /// intersections, keeping portions inside the region, and closing gaps with
-    /// straight lines. No polygon clipping library needed.
+    /// Clip a cutout shape to a region by walking entities and splitting at split-line
+    /// crossings. Only returns the cutout-edge fragments that lie inside the region —
+    /// it deliberately does NOT emit synthetic closing lines at the region boundary.
+    ///
+    /// Rationale: a closing line on the region boundary would overlap the split-line
+    /// feature edge and reintroduce a cut through the cutout interior. The feature
+    /// edge (trimmed against cutouts in <see cref="InsertFeatureEdges"/>) and these
+    /// cutout fragments are stitched together later by <see cref="AssemblePieces"/>
+    /// using endpoint connectivity, which produces the correct closed loops — one
+    /// loop per physically-connected strip of material.
     /// </summary>
     private static List<Entity> ClipCutoutToRegion(Shape cutout, Box region, List<SplitLine> splitLines)
     {
-        var boundarySplitLines = GetBoundarySplitLines(region, splitLines);
         var entities = new List<Entity>();
-        var splitPoints = new List<(Vector Point, SplitLine Line, bool IsExit)>();
-
         foreach (var entity in cutout.Entities)
+            ProcessEntity(entity, region, entities);
+        return entities;
+    }
+
+    /// <summary>
+    /// Groups a region's entities into closed components and nests holes inside
+    /// outer loops by point-in-polygon containment. Returns one entity list per
+    /// output <see cref="Drawing"/> — outer loop first, then its contained holes.
+    /// Each outer loop is normalized to CW winding and each hole to CCW.
+    /// </summary>
+    private static List<List<Entity>> AssemblePieces(List<Entity> entities)
+    {
+        var pieces = new List<List<Entity>>();
+        if (entities.Count == 0) return pieces;
+
+        var shapes = ShapeBuilder.GetShapes(entities);
+        if (shapes.Count == 0) return pieces;
+
+        // Polygonize every shape once so we can run containment tests.
+        var polygons = new List<Polygon>(shapes.Count);
+        foreach (var s in shapes)
+            polygons.Add(s.ToPolygon());
+
+        // Classify each shape as outer or hole using nesting by containment.
+        // Shape A is contained in shape B iff A's bounding box is strictly inside
+        // B's bounding box AND a representative vertex of A lies inside B's polygon.
+        // The bbox pre-check avoids the ambiguity of bbox-center tests when two
+        // shapes share a center (e.g., an outer half and a centered cutout).
+        var isHole = new bool[shapes.Count];
+        for (var i = 0; i < shapes.Count; i++)
         {
-            ProcessEntity(entity, region, boundarySplitLines, entities, splitPoints);
+            var bbA = shapes[i].BoundingBox;
+            var repA = FirstVertexOf(shapes[i]);
+
+            for (var j = 0; j < shapes.Count; j++)
+            {
+                if (i == j) continue;
+                if (polygons[j] == null) continue;
+                if (polygons[j].Vertices.Count < 3) continue;
+
+                var bbB = shapes[j].BoundingBox;
+                if (!BoxContainsBox(bbB, bbA)) continue;
+                if (!polygons[j].ContainsPoint(repA)) continue;
+
+                isHole[i] = true;
+                break;
+            }
         }
 
-        if (entities.Count == 0)
-            return new List<Entity>();
-
-        // Close gaps with straight lines (connect exit→entry pairs)
-        var groups = new Dictionary<SplitLine, List<(Vector Point, bool IsExit)>>();
-        foreach (var sp in splitPoints)
+        // For each outer, attach the holes that fall inside it.
+        for (var i = 0; i < shapes.Count; i++)
         {
-            if (!groups.ContainsKey(sp.Line))
-                groups[sp.Line] = new List<(Vector, bool)>();
-            groups[sp.Line].Add((sp.Point, sp.IsExit));
+            if (isHole[i]) continue;
+
+            var outer = shapes[i];
+            var outerPoly = polygons[i];
+
+            // Enforce perimeter winding = CW.
+            if (outerPoly != null && outerPoly.Vertices.Count >= 3
+                && outerPoly.RotationDirection() != RotationType.CW)
+                outer.Reverse();
+
+            var piece = new List<Entity>();
+            piece.AddRange(outer.Entities);
+
+            for (var j = 0; j < shapes.Count; j++)
+            {
+                if (!isHole[j]) continue;
+                if (polygons[i] == null || polygons[i].Vertices.Count < 3) continue;
+
+                var bbJ = shapes[j].BoundingBox;
+                if (!BoxContainsBox(shapes[i].BoundingBox, bbJ)) continue;
+
+                var rep = FirstVertexOf(shapes[j]);
+                if (!polygons[i].ContainsPoint(rep)) continue;
+
+                var hole = shapes[j];
+                var holePoly = polygons[j];
+                if (holePoly != null && holePoly.Vertices.Count >= 3
+                    && holePoly.RotationDirection() != RotationType.CCW)
+                    hole.Reverse();
+
+                piece.AddRange(hole.Entities);
+            }
+
+            pieces.Add(piece);
         }
 
-        foreach (var kvp in groups)
-        {
-            var sl = kvp.Key;
-            var points = kvp.Value;
-            var isVertical = sl.Axis == CutOffAxis.Vertical;
+        return pieces;
+    }
 
-            var exits = points.Where(p => p.IsExit).Select(p => p.Point)
-                .OrderBy(p => isVertical ? p.Y : p.X).ToList();
-            var entries = points.Where(p => !p.IsExit).Select(p => p.Point)
-                .OrderBy(p => isVertical ? p.Y : p.X).ToList();
+    /// <summary>
+    /// Returns the first vertex of a shape (start point of its first entity). Used as
+    /// a representative for containment testing: if bbox pre-check says the whole
+    /// shape is inside another, testing one vertex is sufficient to confirm.
+    /// </summary>
+    private static Vector FirstVertexOf(Shape shape)
+    {
+        if (shape.Entities.Count == 0)
+            return new Vector(0, 0);
+        return GetStartPoint(shape.Entities[0]);
+    }
 
-            var pairCount = System.Math.Min(exits.Count, entries.Count);
-            for (var i = 0; i < pairCount; i++)
-                entities.Add(new Line(exits[i], entries[i]));
-        }
-
-        // Ensure CCW winding for cutouts
-        var shape = new Shape();
-        shape.Entities.AddRange(entities);
-        var poly = shape.ToPolygon();
-        if (poly != null && poly.RotationDirection() != RotationType.CCW)
-            shape.Reverse();
-
-        return shape.Entities;
+    /// <summary>
+    /// True iff box <paramref name="inner"/> is entirely inside box
+    /// <paramref name="outer"/> (tolerant comparison).
+    /// </summary>
+    private static bool BoxContainsBox(Box outer, Box inner)
+    {
+        var eps = Math.Tolerance.Epsilon;
+        return inner.Left >= outer.Left - eps
+            && inner.Right <= outer.Right + eps
+            && inner.Bottom >= outer.Bottom - eps
+            && inner.Top <= outer.Top + eps;
     }
 
     private static Vector GetStartPoint(Entity entity)

OpenNest.Engine.Tests/Jobs/FiniteStockJobTests.cs

@@ -0,0 +1,183 @@
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class FiniteStockJobTests
+{
+    internal static NestJob Job(int? stock = 3, NestJobOptions? options = null) => new(
+        new[] { new NestJobPart("p", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle()), 3) },
+        new[] { new NestPlateStock("s", new Size(100, 200), stock) }, options);
+
+    internal sealed class Nester(Func<PlatePlacementRequest, PlateCandidate> place) : IPlateNester
+    {
+        public int Calls { get; private set; }
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default) { Calls++; return place(request); }
+    }
+
+    internal static PlateCandidate One(PlatePlacementRequest request) => new(new[]
+        { new NestJobPlacement(request.Parts[0].Id, 99, 0, 0, 0) });
+
+    [Theory]
+    [InlineData(3, 3, 0, NestJobStatus.Complete, NestJobStopReason.Completed)]
+    [InlineData(2, 2, 1, NestJobStatus.Incomplete, NestJobStopReason.StockExhausted)]
+    [InlineData(0, 0, 3, NestJobStatus.Incomplete, NestJobStopReason.StockExhausted)]
+    public void DemandAndPhysicalStockAreAccountedFromPlacements(int stock, int placed, int left,
+        NestJobStatus status, NestJobStopReason reason)
+    {
+        var requests = new List<int>();
+        var nester = new Nester(r => { requests.Add(r.Parts[0].Quantity); return One(r); });
+        var job = Job(stock);
+        var result = new NestJobRunner(_ => nester).Solve(job);
+        Assert.Equal(status, result.Status);
+        Assert.Equal(reason, result.StopReason);
+        Assert.Equal(placed, result.Plates.Count);
+        Assert.All(result.Plates, p => Assert.Single(p.Placements));
+        Assert.Equal(Enumerable.Range(0, placed), result.Plates.SelectMany(p => p.Placements).Select(p => p.InstanceIndex));
+        Assert.Equal(Enumerable.Range(0, placed).Select(i => 3 - i), requests);
+        Assert.Equal(new PartFulfillment("p", 3, placed, left), Assert.Single(result.Fulfillment));
+        Assert.Equal(new StockUsage("s", placed, stock - placed), Assert.Single(result.StockUsage));
+        Assert.Equal(3, job.Parts[0].Quantity);
+        Assert.Equal(stock, job.Plates[0].Quantity);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData(3)]
+    public void NoPlacementStopsWithoutConsumingStock(int? stock)
+    {
+        var nester = new Nester(_ => new PlateCandidate(Array.Empty<NestJobPlacement>()));
+        var result = new NestJobRunner(_ => nester).Solve(Job(stock));
+        Assert.Equal(1, nester.Calls);
+        Assert.Empty(result.Plates);
+        Assert.Equal(NestJobStatus.Incomplete, result.Status);
+        Assert.Equal(NestJobStopReason.NoPlacementFound, result.StopReason);
+        Assert.Equal(new StockUsage("s", 0, stock), Assert.Single(result.StockUsage));
+    }
+
+    [Fact]
+    public void PlateLimitStopsUnlimitedStock()
+    {
+        var result = new NestJobRunner(_ => new Nester(One)).Solve(Job(null, new NestJobOptions(maxPlates: 2)));
+        Assert.Equal(2, result.Plates.Count);
+        Assert.Equal(NestJobStopReason.PlateLimitReached, result.StopReason);
+        Assert.Equal(new StockUsage("s", 2, null), Assert.Single(result.StockUsage));
+    }
+
+    [Fact]
+    public void CancellationImmediatelyAfterEngineReturnThrowsWithoutCommit()
+    {
+        using var cts = new CancellationTokenSource();
+        var commits = new List<NestJobProgress>();
+        var nester = new Nester(r => { cts.Cancel(); return One(r); });
+        Assert.Throws<OperationCanceledException>(() => new NestJobRunner(_ => nester)
+            .Solve(Job(), new InlineProgress(commits.Add), cts.Token));
+        Assert.DoesNotContain(commits, p => p.Stage == NestJobStage.PlateCommitted);
+    }
+
+    [Fact]
+    public void InitialCancellationSkipsEngine()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        Assert.Throws<OperationCanceledException>(() => new NestJobRunner(_ => throw new Exception("called"))
+            .Solve(Job(), token: cts.Token));
+    }
+
+    [Theory]
+    [InlineData("unknown", 0, 0, 0, 1)]
+    [InlineData("p", double.NaN, 0, 0, 1)]
+    [InlineData("p", 0, double.PositiveInfinity, 0, 1)]
+    [InlineData("p", 0, 0, double.NaN, 1)]
+    [InlineData("p", 0, 0, 0, 4)]
+    public void InvalidCandidateThrows(string id, double x, double y, double rotation, int count)
+    {
+        var nester = new Nester(_ => new PlateCandidate(Enumerable.Range(0, count)
+            .Select(i => new NestJobPlacement(id, i, x, y, rotation))));
+        Assert.Throws<InvalidOperationException>(() => new NestJobRunner(_ => nester).Solve(Job()));
+    }
+
+    [Fact]
+    public void NullCandidateAndUnknownStrategyAreExplicitErrors()
+    {
+        Assert.Throws<InvalidOperationException>(() => new NestJobRunner(_ => new Nester(_ => null!)).Solve(Job()));
+        Assert.Throws<NotSupportedException>(() => new NestJobRunner(_ => null!).Solve(Job(options: new NestJobOptions("missing"))));
+    }
+
+    [Fact]
+    public void MixedStockCanBeEvaluated()
+    {
+        var job = Job();
+        var mixed = new NestJob(job.Parts, job.Plates.Concat(new[] { new NestPlateStock("other", new Size(20, 10), 2) }));
+        var result = new NestJobRunner(_ => new Nester(One)).Solve(mixed);
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+    }
+
+    [Theory]
+    [InlineData(0, 20, 0, 1)]
+    [InlineData(10, double.NaN, 0, 1)]
+    [InlineData(10, 20, -1, 1)]
+    [InlineData(10, 20, double.PositiveInfinity, 1)]
+    [InlineData(10, 20, 0, 5)]
+    public void InvalidStockSettingsRejected(double width, double length, double spacing, int quadrant)
+    {
+        var job = new NestJob(Job().Parts, new[] { new NestPlateStock("s", new Size(width, length), 1, spacing, quadrant: quadrant) });
+        Assert.Throws<ArgumentException>(() => new NestJobRunner(_ => new Nester(One)).Solve(job));
+    }
+
+    [Fact]
+    public void InvalidEdgesAndGeometryRejected()
+    {
+        var runner = new NestJobRunner(_ => new Nester(One));
+        foreach (var edges in new[] { new Spacing(-1, 0, 0, 0), new Spacing(0, double.NaN, 0, 0), new Spacing(1000, 1000, 1000, 1000) })
+            Assert.Throws<ArgumentException>(() => runner.Solve(new NestJob(Job().Parts,
+                new[] { new NestPlateStock("s", new Size(100, 200), edgeSpacing: edges) })));
+        var program = TestDrawingFactory.Rectangle();
+        program.LineTo(double.NaN, 0);
+        Assert.Throws<ArgumentException>(() => runner.Solve(new NestJob(new[]
+            { new NestJobPart("p", PartGeometrySnapshot.FromProgram(program), 1) }, Job().Plates)));
+    }
+
+    [Fact]
+    public void InvalidContractInputsAreRejected()
+    {
+        var job = Job();
+        Assert.Throws<ArgumentNullException>(() => new NestJobRunner(_ => new Nester(One)).Solve(null!));
+        Assert.Throws<ArgumentException>(() => new NestJob(new NestJobPart[] { null! }, job.Plates));
+        Assert.Throws<ArgumentException>(() => new NestJob(job.Parts.Concat(job.Parts), job.Plates));
+        Assert.Throws<ArgumentException>(() => new NestJob(job.Parts, job.Plates.Concat(job.Plates)));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new NestJobPart("p", job.Parts[0].Geometry, 0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new NestPlateStock("s", new Size(1, 1), -1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new NestJobOptions(maxPlates: 0));
+    }
+
+    [Fact]
+    public void RunnerFactoriesAreInstanceScopedAndReceiveExactStrategyKeys()
+    {
+        var keys = new List<string>();
+        var first = new NestJobRunner(key => { keys.Add(key); return new Nester(One); });
+        var second = new NestJobRunner(key => { keys.Add(key); return new Nester(_ => new PlateCandidate(Array.Empty<NestJobPlacement>())); });
+        Assert.Equal(NestJobStatus.Complete, first.Solve(Job(options: new NestJobOptions("custom-A"))).Status);
+        Assert.Equal(NestJobStopReason.NoPlacementFound, second.Solve(Job(options: new NestJobOptions("custom-B"))).StopReason);
+        Assert.Equal(NestJobStatus.Complete, first.Solve(Job(options: new NestJobOptions("custom-A"))).Status);
+        Assert.Equal(new[] { "custom-A", "custom-B", "custom-A" }, keys);
+    }
+
+    [Fact]
+    public void CancellationAfterAnEarlierCommitStillThrowsRatherThanReturningPartialResult()
+    {
+        using var cts = new CancellationTokenSource();
+        var calls = 0;
+        var commits = new List<NestJobProgress>();
+        var nester = new Nester(r => { if (++calls == 2) cts.Cancel(); return One(r); });
+        Assert.Throws<OperationCanceledException>(() => new NestJobRunner(_ => nester)
+            .Solve(Job(), new InlineProgress(commits.Add), cts.Token));
+        Assert.Equal(1, Assert.Single(commits.Where(p => p.Stage == NestJobStage.PlateCommitted)).CommittedParts);
+        Assert.Equal(2, calls);
+    }
+
+    private sealed class InlineProgress(Action<NestJobProgress> report) : IProgress<NestJobProgress>
+    {
+        public void Report(NestJobProgress value) => report(value);
+    }
+}

OpenNest.Engine.Tests/Jobs/JobAdapterTests.cs

@@ -0,0 +1,162 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class JobAdapterTests
+{
+    [Fact]
+    public void LegacyMutationsCannotDoubleSubtractOrReachCallerObjects()
+    {
+        var drawing = new Drawing("same name", TestDrawingFactory.Rectangle());
+        drawing.Quantity.Required = 9;
+        var item = new NestItem { Drawing = drawing, Quantity = 3, Priority = 7, StepAngle = 0 };
+        var sourcePlate = new Plate(100, 200) { Quantity = 3, PartSpacing = 2 };
+        var job = new NestJob(new[] { DrawingJobMapper.FromItem("requirement", item) },
+            new[] { DrawingJobMapper.FromPlate("stock", sourcePlate, 3) });
+        var quantities = new List<int>();
+        var adapter = new LegacyPlateNesterAdapter(p => new MutatingEngine(p, items =>
+        {
+            var privateItem = Assert.Single(items);
+            quantities.Add(privateItem.Quantity);
+            Assert.NotSame(drawing, privateItem.Drawing);
+            Assert.Equal(0, privateItem.StepAngle);
+            Assert.Equal(7, privateItem.Priority);
+            var part = new Part(privateItem.Drawing);
+            privateItem.Quantity = 0;
+            privateItem.Drawing.Quantity.Required = 0;
+            return new List<Part> { part };
+        }));
+        var result = new NestJobRunner(_ => adapter).Solve(job);
+        var materialized = NestResultMaterializer.Materialize(job, result);
+        Assert.Equal(new[] { 3, 2, 1 }, quantities);
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(3, materialized.Nest.Plates.Count);
+        Assert.All(materialized.Nest.Plates, p => { Assert.Equal(1, p.Quantity); Assert.Single(p.Parts); });
+        var outputDrawing = materialized.DrawingsByPartId["requirement"];
+        Assert.Equal(3, outputDrawing.Quantity.Required);
+        Assert.Equal(3, outputDrawing.Quantity.Nested);
+        Assert.All(materialized.Nest.Plates, p => Assert.Same(outputDrawing, p.Parts[0].BaseDrawing));
+        Assert.NotSame(drawing, outputDrawing);
+        Assert.Equal(9, drawing.Quantity.Required);
+        Assert.Equal(0, drawing.Quantity.Nested);
+        Assert.Equal(3, item.Quantity);
+        Assert.Equal(3, sourcePlate.Quantity);
+        Assert.Empty(sourcePlate.Parts);
+        Assert.Equal(2, sourcePlate.PartSpacing);
+        Assert.Equal(PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle()).Motions,
+            PartGeometrySnapshot.FromProgram(drawing.Program).Motions);
+    }
+
+    [Fact]
+    public void ReferenceIdentityNotNamesControlsLegacyPlacements()
+    {
+        var drawing = new Drawing("duplicate", TestDrawingFactory.Rectangle());
+        var job = new NestJob(new[] { DrawingJobMapper.FromDrawing("a", drawing, 1),
+            DrawingJobMapper.FromDrawing("b", drawing, 1) }, FiniteStockJobTests.Job(1).Plates);
+        var adapter = new LegacyPlateNesterAdapter(p => new MutatingEngine(p, items =>
+        {
+            Assert.NotSame(items[0].Drawing, items[1].Drawing);
+            foreach (var item in items) item.Drawing.Name = "identical";
+            return new List<Part>
+            {
+                new Part(items[0].Drawing, new Vector(0, 0)),
+                new Part(items[1].Drawing, new Vector(10, 0))
+            };
+        }));
+        var result = new NestJobRunner(_ => adapter).Solve(job);
+        Assert.Equal(new[] { "a", "b" }, result.Plates[0].Placements.Select(p => p.PartId));
+        var output = NestResultMaterializer.Materialize(job, result);
+        Assert.NotSame(output.DrawingsByPartId["a"], output.DrawingsByPartId["b"]);
+        Assert.All(output.DrawingsByPartId.Values, d => Assert.Equal(1, d.Quantity.Nested));
+    }
+
+    [Fact]
+    public void UnknownPrivateDrawingIsRejectedEvenWithMatchingName()
+    {
+        var adapter = new LegacyPlateNesterAdapter(p => new MutatingEngine(p, items => new List<Part>
+            { new(new Drawing(items[0].Drawing.Name, TestDrawingFactory.Rectangle())) }));
+        Assert.Throws<InvalidOperationException>(() => new NestJobRunner(_ => adapter).Solve(FiniteStockJobTests.Job()));
+        Assert.Throws<NotSupportedException>(() => LegacyPlateNesterAdapter.Create("not registered"));
+    }
+
+    [Fact]
+    public void ExactGeometryRoundTripsIncludingOriginArcHoleAndMode()
+    {
+        var program = TestDrawingFactory.Rectangle();
+        program.Offset(-17.123456789, 5.25);
+        program.MoveTo(-14, 9);
+        program.ArcTo(-14, 9, -13, 9, RotationType.CW);
+        ((ArcMove)program.Codes[^1]).Layer = LayerType.Cut;
+        var drawing = new Drawing("shape", program);
+        var part = DrawingJobMapper.FromDrawing("p", drawing, 1);
+        var snapshot = part.Geometry.Motions.ToArray();
+        ((Motion)program.Codes[1]).EndPoint = new Vector(999, 888);
+        Assert.Equal(snapshot, part.Geometry.Motions);
+        var roundTrip = DrawingJobMapper.ToProgram(part.Geometry);
+        Assert.Equal(snapshot, PartGeometrySnapshot.FromProgram(roundTrip).Motions);
+        Assert.Equal(program.Mode, roundTrip.Mode);
+        roundTrip.Codes.Clear();
+        Assert.Equal(snapshot, part.Geometry.Motions);
+        var incremental = new Program(Mode.Incremental);
+        incremental.MoveTo(5, -3);
+        incremental.LineTo(7, 4);
+        var incrementalSnapshot = PartGeometrySnapshot.FromProgram(incremental);
+        Assert.Equal(Mode.Incremental, DrawingJobMapper.ToProgram(incrementalSnapshot).Mode);
+        Assert.Equal(incrementalSnapshot.Motions,
+            PartGeometrySnapshot.FromProgram(DrawingJobMapper.ToProgram(incrementalSnapshot)).Motions);
+    }
+
+    [Fact]
+    public void RealDefaultEngineRunsFromDrawingThroughMaterialization()
+    {
+        var drawing = new Drawing("generated asymmetric rectangle", TestDrawingFactory.Rectangle(13, 7));
+        drawing.Quantity.Required = 1;
+        var job = new NestJob(new[] { DrawingJobMapper.FromDrawing("rectangle", drawing, 1) },
+            new[] { new NestPlateStock("sheet", new Size(40, 60), 1, 1, new Spacing(2, 2, 2, 2)) });
+        var result = new NestJobRunner(LegacyPlateNesterAdapter.Create).Solve(job);
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(new StockUsage("sheet", 1, 0), Assert.Single(result.StockUsage));
+        var pose = Assert.Single(Assert.Single(result.Plates).Placements);
+        var output = NestResultMaterializer.Materialize(job, result);
+        var physicalPlate = Assert.Single(output.Nest.Plates);
+        var placed = Assert.Single(physicalPlate.Parts);
+        Assert.Equal(1, physicalPlate.Quantity);
+        Assert.Same(output.DrawingsByPartId["rectangle"], placed.BaseDrawing);
+        Assert.Equal(pose.X, placed.Location.X);
+        Assert.Equal(pose.Y, placed.Location.Y);
+        Assert.Equal(pose.Rotation, placed.Rotation, 10);
+        Assert.Equal(1, placed.BaseDrawing.Quantity.Nested);
+        Assert.Equal(0, drawing.Quantity.Nested);
+        Assert.Equal(1, drawing.Quantity.Required);
+        var bounds = placed.BoundingBox;
+        var work = physicalPlate.WorkArea();
+        Assert.True(bounds.Left >= work.Left - 1e-6 && bounds.Bottom >= work.Bottom - 1e-6);
+        Assert.True(bounds.Right <= work.Right + 1e-6 && bounds.Top <= work.Top + 1e-6);
+    }
+
+    [Fact]
+    public void MaterializationRotatesAboutSnapshotOriginThenTranslates()
+    {
+        var program = TestDrawingFactory.Rectangle();
+        program.Offset(-5, 3);
+        var job = new NestJob(new[] { new NestJobPart("p", PartGeometrySnapshot.FromProgram(program), 1) },
+            FiniteStockJobTests.Job(1).Plates);
+        var result = new NestJobRunner(_ => new FiniteStockJobTests.Nester(_ => new PlateCandidate(new[]
+            { new NestJobPlacement("p", 0, 23, 31, 0.7) }))).Solve(job);
+        var output = NestResultMaterializer.Materialize(job, result);
+        var part = output.Nest.Plates[0].Parts[0];
+        var expected = new Vector(-5, 3).Rotate(0.7);
+        Assert.Equal(expected.X, ((Motion)part.Program.Codes[0]).EndPoint.X, 10);
+        Assert.Equal(expected.Y, ((Motion)part.Program.Codes[0]).EndPoint.Y, 10);
+        Assert.Equal(new Vector(23, 31), part.Location);
+    }
+
+    private sealed class MutatingEngine(Plate plate, Func<List<NestItem>, List<Part>> nest) : NestEngineBase(plate)
+    {
+        public override string Name => "test";
+        public override string Description => "mutates private demand";
+        public override List<Part> Nest(List<NestItem> items, IProgress<NestProgress> progress, CancellationToken token)
+            => nest(items);
+    }
+}

OpenNest.Engine.Tests/Jobs/NestJobCancellationTests.cs

@@ -0,0 +1,114 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestJobCancellationTests
+{
+    [Fact]
+    public void PreTrialCancellationSkipsCandidateWorkAndPreservesInput()
+    {
+        using var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+        var nester = new CancellableNester(_ => new PlateCandidate(Array.Empty<NestJobPlacement>()));
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 1);
+        var sourceGeometry = part.Geometry.Motions.ToArray();
+        var stock = new NestPlateStock("stock", new Size(20, 30), 1);
+        var job = new NestJob(new[] { part }, new[] { stock });
+
+        Assert.Throws<OperationCanceledException>(() => new NestJobRunner(_ => nester).Solve(job, token: cancellation.Token));
+
+        Assert.Equal(0, nester.Calls);
+        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
+        Assert.Equal(1, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+    }
+
+    [Fact]
+    public void CancellationDuringCandidateThrowsWithoutCommitOrInputMutation()
+    {
+        using var cancellation = new CancellationTokenSource();
+        var reports = new List<NestJobProgress>();
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 1);
+        var sourceGeometry = part.Geometry.Motions.ToArray();
+        var stock = new NestPlateStock("stock", new Size(20, 30), 1);
+        var job = new NestJob(new[] { part }, new[] { stock });
+        var nester = new CancellableNester((_, token) =>
+        {
+            cancellation.Cancel();
+            token.ThrowIfCancellationRequested();
+            return new PlateCandidate(Array.Empty<NestJobPlacement>());
+        });
+
+        Assert.Throws<OperationCanceledException>(() => new NestJobRunner(_ => nester)
+            .Solve(job, new InlineProgress(reports.Add), cancellation.Token));
+
+        Assert.Equal(1, nester.Calls);
+        Assert.DoesNotContain(reports, report => report.Stage == NestJobStage.PlateCommitted);
+        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
+        Assert.Equal(1, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+    }
+
+    [Fact]
+    public void LegacyProgressIsWrappedWithCurrentCandidateContext()
+    {
+        var reports = new List<NestJobProgress>();
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 1);
+        var job = new NestJob(new[] { part }, new[] { new NestPlateStock("stock", new Size(20, 30), 1) });
+        var runner = new NestJobRunner(_ => new LegacyPlateNesterAdapter(plate => new ReportingEngine(plate)));
+
+        var result = runner.Solve(job, new InlineProgress(reports.Add));
+
+        Assert.Equal(NestJobStopReason.NoPlacementFound, result.StopReason);
+        var legacy = Assert.Single(reports.Where(report => report.LegacyProgress != null));
+        Assert.Equal(NestJobStage.EvaluatingCandidate, legacy.Stage);
+        Assert.Equal("stock", legacy.StockId);
+        Assert.Equal(0, legacy.PlateIndex);
+        Assert.Equal(0, legacy.CommittedPlates);
+        Assert.Equal(0, legacy.CommittedParts);
+        Assert.Equal("legacy detail", legacy.LegacyProgress!.Description);
+    }
+
+    private sealed class InlineProgress(Action<NestJobProgress> report) : IProgress<NestJobProgress>
+    {
+        public void Report(NestJobProgress value) => report(value);
+    }
+
+    private sealed class CancellableNester : IPlateNester
+    {
+        private readonly Func<PlatePlacementRequest, CancellationToken, PlateCandidate> place;
+
+        public CancellableNester(Func<PlatePlacementRequest, PlateCandidate> place)
+        {
+            this.place = (request, _) => place(request);
+        }
+
+        public CancellableNester(Func<PlatePlacementRequest, CancellationToken, PlateCandidate> place)
+        {
+            this.place = place;
+        }
+
+        public int Calls { get; private set; }
+
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default)
+        {
+            Calls++;
+            return place(request, token);
+        }
+    }
+
+    private sealed class ReportingEngine(Plate plate) : NestEngineBase(plate)
+    {
+        public override string Name => "reporting";
+        public override string Description => "reports progress";
+
+        public override List<Part> Nest(List<NestItem> items, IProgress<NestProgress>? progress,
+            CancellationToken token)
+        {
+            progress?.Report(new NestProgress { Description = "legacy detail" });
+            return new List<Part>();
+        }
+    }
+}

OpenNest.Engine.Tests/Jobs/NestJobEngineSelectionTests.cs

@@ -0,0 +1,86 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+/// <summary>
+/// Strategy selection must be instance-scoped: explicit engine choices work without touching the
+/// process-global NestEngineRegistry.ActiveEngineName, and unknown strategies are rejected.
+/// </summary>
+public class NestJobEngineSelectionTests
+{
+    [Fact]
+    public void ExplicitDefaultAndStripSelectionsDoNotTouchGlobalRegistry()
+    {
+        var original = NestEngineRegistry.ActiveEngineName;
+        var job = FiniteStockJobTests.Job(1);
+
+        var defaultResult = new NestJobRunner(PlateNesterFactory.Create).Solve(job);
+        Assert.Equal(NestJobStatus.Complete, defaultResult.Status);
+
+        var stripResult = new NestJobRunner(PlateNesterFactory.Create)
+            .Solve(new NestJob(job.Parts, job.Plates, new NestJobOptions("Strip")));
+        Assert.Equal(NestJobStatus.Complete, stripResult.Status);
+
+        Assert.Equal(original, NestEngineRegistry.ActiveEngineName);
+    }
+
+    [Fact]
+    public void FactoryResolvesNamedEnginesWithoutGlobalState()
+    {
+        var original = NestEngineRegistry.ActiveEngineName;
+        var defaultNester = PlateNesterFactory.Create("Default");
+        var stripNester = PlateNesterFactory.Create("Strip");
+        var verticalNester = PlateNesterFactory.Create("Vertical Remnant");
+        var horizontalNester = PlateNesterFactory.Create("Horizontal Remnant");
+
+        Assert.NotNull(defaultNester);
+        Assert.NotNull(stripNester);
+        Assert.NotNull(verticalNester);
+        Assert.NotNull(horizontalNester);
+        Assert.NotSame(defaultNester, stripNester);
+        Assert.Equal(original, NestEngineRegistry.ActiveEngineName);
+    }
+
+    [Fact]
+    public void UnknownStrategyIsRejected()
+    {
+        Assert.Throws<NotSupportedException>(() => PlateNesterFactory.Create("Not A Real Engine"));
+        var job = FiniteStockJobTests.Job(1);
+        Assert.Throws<NotSupportedException>(() =>
+            new NestJobRunner(key => throw new NotSupportedException($"Unknown placement strategy: {key}"))
+                .Solve(new NestJob(job.Parts, job.Plates, new NestJobOptions("Bogus"))));
+    }
+
+    [Fact]
+    public void LegacyRegistryPluginsDoNotLeakIntoJobSelection()
+    {
+        // A plugin engine registered through the legacy registry must not become selectable
+        // through the job factory; the new boundary is independent of registry state.
+        NestEngineRegistry.Register("ProbePlugin", "test plugin", plate => new PluginShapeEngine(plate));
+        Assert.Contains(NestEngineRegistry.AvailableEngines, e => e.Name == "ProbePlugin");
+
+        Assert.Throws<NotSupportedException>(() => PlateNesterFactory.Create("ProbePlugin"));
+        Assert.NotNull(PlateNesterFactory.Create("Default"));
+    }
+
+    [Fact]
+    public void StripEngineEndToEndPlacesAndAccounts()
+    {
+        var drawing = new Drawing("strip part", TestDrawingFactory.Rectangle(30, 30));
+        var job = new NestJob(new[] { DrawingJobMapper.FromDrawing("part", drawing, 2) },
+            new[] { new NestPlateStock("s", new Size(90, 90), 1) });
+        var result = new NestJobRunner(PlateNesterFactory.Create)
+            .Solve(new NestJob(job.Parts, job.Plates, new NestJobOptions("Strip")));
+
+        Assert.True(result.Plates.SelectMany(p => p.Placements).Count() >= 1);
+        foreach (var f in result.Fulfillment)
+            Assert.Equal(f.Requested, f.Placed + f.Unplaced);
+    }
+
+    private sealed class PluginShapeEngine(Plate plate) : NestEngineBase(plate)
+    {
+        public override string Name => "ProbePlugin";
+        public override string Description => "registered via legacy registry only";
+    }
+}

OpenNest.Engine.Tests/Jobs/NestJobExampleTests.cs

@@ -0,0 +1,148 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using Xunit;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+/// <summary>
+/// Runnable end-to-end example of the whole-job engine API: multiple part requirements, multiple plate
+/// sizes, and an enumeration of every returned plate, placement, leftover, and stock line. Also the
+/// documentation checkpoint for the legacy caller boundaries that have not been migrated (task 8).
+/// </summary>
+public class NestJobExampleTests
+{
+    [Fact]
+    public void MultiRequirementMultiStockJobEnumeratesEveryPlateAndLeftover()
+    {
+        // Two requirements with independent IDs, quantities, and priorities.
+        var job = new NestJob(
+            new[]
+            {
+                Part("bracket", 100.0, 60.0, 5, priority: 0),
+                Part("plate-clip", 40.0, 40.0, 8, priority: 1),
+            },
+            // Mixed inventory: five large sheets and unlimited small sheets.
+            new[]
+            {
+                new NestPlateStock("large", new Size(600.0, 400.0), quantity: 5, partSpacing: 2.0,
+                    edgeSpacing: new Spacing(5.0, 5.0, 5.0, 5.0), quadrant: 1),
+                new NestPlateStock("small", new Size(300.0, 300.0), quantity: null, partSpacing: 2.0,
+                    edgeSpacing: new Spacing(5.0, 5.0, 5.0, 5.0), quadrant: 1),
+            });
+
+        var result = new NestJobRunner(PlateNesterFactory.Create).Solve(job);
+
+        // -- Every physical plate is enumerated with its stock identity and placements. --
+        Console.WriteLine($"Status: {result.Status}, stop reason: {result.StopReason}.");
+        foreach (var plate in result.Plates)
+        {
+            Console.WriteLine($"Plate {plate.PlateIndex} from stock '{plate.StockId}' " +
+                $"({plate.Stock.Size.Width} x {plate.Stock.Size.Length}):");
+            foreach (var placement in plate.Placements)
+                Console.WriteLine($"  {placement.PartId} #{placement.InstanceIndex} at " +
+                    $"({placement.X:F1}, {placement.Y:F1}) rotated {placement.Rotation:F3} rad.");
+        }
+
+        // -- Every requirement reports exact fulfillment, including leftovers. --
+        foreach (var fulfillment in result.Fulfillment)
+            Console.WriteLine($"Requirement '{fulfillment.PartId}': requested {fulfillment.Requested}, " +
+                $"placed {fulfillment.Placed}, unplaced {fulfillment.Unplaced}.");
+
+        // -- Every stock line reports physical sheets used and remaining availability. --
+        foreach (var usage in result.StockUsage)
+            Console.WriteLine($"Stock '{usage.StockId}': used {usage.Used}, " +
+                $"remaining {(usage.Remaining.HasValue ? usage.Remaining.Value.ToString() : "unlimited")}.");
+
+        // Invariants the enumeration relies on: conservation per requirement and per stock line, no
+        // empty plates, every plate bound to supplied stock, and per-placement instance accounting.
+        foreach (var fulfillment in result.Fulfillment)
+        {
+            Assert.Equal(fulfillment.Requested, fulfillment.Placed + fulfillment.Unplaced);
+            Assert.True(fulfillment.Unplaced >= 0);
+        }
+        foreach (var usage in result.StockUsage)
+        {
+            var stock = job.Plates.First(candidate => candidate.Id == usage.StockId);
+            Assert.True(usage.Used >= 0);
+            Assert.Equal(stock.Quantity is int capacity ? capacity - usage.Used : (int?)null, usage.Remaining);
+        }
+
+        Assert.All(result.Plates, plate => Assert.NotEmpty(plate.Placements));
+        var plateCountByStock = result.Plates.GroupBy(plate => plate.StockId)
+            .ToDictionary(group => group.Key, group => group.Count());
+        foreach (var usage in result.StockUsage)
+            Assert.Equal(usage.Used, plateCountByStock.GetValueOrDefault(usage.StockId));
+
+        var instanceIndicesByPart = result.Plates
+            .SelectMany(plate => plate.Placements)
+            .GroupBy(placement => placement.PartId)
+            .ToDictionary(group => group.Key, group => group.Select(placement => placement.InstanceIndex));
+        foreach (var fulfillment in result.Fulfillment)
+            Assert.Equal(Enumerable.Range(0, fulfillment.Placed),
+                instanceIndicesByPart.GetValueOrDefault(fulfillment.PartId, new List<int>()).OrderBy(index => index));
+
+        // The default heuristic completes this synthetic job from the mixed inventory.
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(NestJobStopReason.Completed, result.StopReason);
+        Assert.Equal(5, result.Fulfillment.Single(fulfillment => fulfillment.PartId == "bracket").Placed);
+        Assert.Equal(8, result.Fulfillment.Single(fulfillment => fulfillment.PartId == "plate-clip").Placed);
+    }
+
+    [Fact]
+    public void MaxPlatesExampleShowsExplicitLeftovers()
+    {
+        // Same shape of job, but a plate budget forces an explicit partial result.
+        var job = new NestJob(
+            new[] { Part("part", 100.0, 100.0, 6, priority: 0) },
+            new[] { new NestPlateStock("sheet", new Size(220.0, 220.0), quantity: null, partSpacing: 2.0,
+                edgeSpacing: new Spacing(5.0, 5.0, 5.0, 5.0), quadrant: 1) },
+            new NestJobOptions("Default", maxPlates: 1));
+
+        var result = new NestJobRunner(PlateNesterFactory.Create).Solve(job);
+
+        Assert.Equal(NestJobStatus.Incomplete, result.Status);
+        Assert.Equal(NestJobStopReason.PlateLimitReached, result.StopReason);
+        var single = Assert.Single(result.Plates);
+        Assert.Equal("sheet", single.StockId);
+        var fulfillment = Assert.Single(result.Fulfillment);
+        Assert.Equal(6, fulfillment.Requested);
+        Assert.Equal(single.Placements.Count, fulfillment.Placed);
+        Assert.Equal(fulfillment.Requested - fulfillment.Placed, fulfillment.Unplaced);
+    }
+
+    /// <summary>
+    /// Legacy caller boundaries documented for task 8 — these paths still use the old single-plate
+    /// engine entry points and are deliberately NOT migrated in this slice. Verified against source at
+    /// the time of writing:
+    /// - Desktop UI: OpenNest/Forms/MainForm.cs RunAutoNestAsync (~line 1004) and NestSinglePlateAsync
+    ///   (~line 1087) orchestrate plate-first and part-first fills directly against NestEngineRegistry
+    ///   engines. Migration requires preserving populated-plate editing, preview routing, and
+    ///   Accept-versus-Cancel semantics — a separate adapter design (documented follow-on).
+    /// - CLI: OpenNest.Console/Program.cs calls engine.Nest(...) (~line 316) on one plate. Migration
+    ///   point: build a NestJob from imported drawings plus CLI plate options and call Solve once.
+    /// - MCP: OpenNest.Mcp/Tools/NestingTools.cs calls engine.Nest(...) (~line 239) on the session
+    ///   plate. Migration point: same single job call, materialized through NestResultMaterializer.
+    /// The public API (OpenNest.Api NestRunner) already delegates to NestJobRunner.Solve (task 6).
+    /// This test exercises the legacy compatibility signature so an accidental removal of that entry
+    /// point breaks the documented contract.
+    /// </summary>
+    [Fact]
+    public void LegacyCompatibilityEntryPointsStillExist()
+    {
+        var plate = new Plate { Size = new Size(300.0, 200.0), Quadrant = 1 };
+        var drawing = new Drawing("legacy", TestDrawingFactory.Rectangle(50.0, 50.0));
+        var item = new NestItem { Drawing = drawing, Quantity = 1 };
+
+        // MainForm/Console/MCP still reach the legacy single-plate signature unchanged; the engine
+        // returns placed Parts for the caller to attach (legacy paths do not attach on their own).
+        var engine = NestEngineRegistry.Create(plate);
+        var parts = engine.Nest(new List<NestItem> { item }, null, CancellationToken.None);
+
+        Assert.NotNull(engine);
+        var placed = Assert.Single(parts);
+        Assert.Same(drawing, placed.BaseDrawing);
+    }
+
+    private static NestJobPart Part(string id, double width, double length, int quantity, int priority) =>
+        new(id, PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(width, length)), quantity, priority);
+}

OpenNest.Engine.Tests/Jobs/NestJobGeometryTests.cs

@@ -0,0 +1,159 @@
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestJobGeometryTests
+{
+    [Fact]
+    public void CandidateOutsideUsableWorkAreaFailsWithoutMutatingInput()
+    {
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 1);
+        var sourceGeometry = part.Geometry.Motions.ToArray();
+        var stock = new NestPlateStock("stock", new Size(20, 30), 1,
+            edgeSpacing: new Spacing(2, 1, 3, 4));
+        var job = new NestJob(new[] { part }, new[] { stock });
+        var runner = new NestJobRunner(_ => new CandidateNester(new[] { new NestJobPlacement("part", 0, 26, 1, 0) }));
+
+        Assert.Throws<InvalidOperationException>(() => runner.Solve(job));
+
+        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
+        Assert.Equal(1, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+    }
+
+    [Theory]
+    [InlineData(1, 0, 0)]
+    [InlineData(2, -11, 0)]
+    [InlineData(3, -11, -7)]
+    [InlineData(4, 0, -7)]
+    public void UnequalRectanglesFitAtEachQuadrantsUsableOrigin(int quadrant, double x, double y)
+    {
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 3)), 1);
+        var stock = new NestPlateStock("stock", new Size(7, 11), 1, quadrant: quadrant);
+        var job = new NestJob(new[] { part }, new[] { stock });
+
+        var result = Solve(job, new NestJobPlacement("part", 0, x, y, 0));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(new NestJobPlacement("part", 0, x, y, 0), Assert.Single(result.Plates[0].Placements));
+    }
+
+    [Fact]
+    public void FixedAndBoundedRotationPoliciesRejectDisallowedAngles()
+    {
+        var fixedPart = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 2)), 1,
+            rotation: RotationPolicy.Fixed(System.Math.PI / 2));
+        var fixedJob = new NestJob(new[] { fixedPart }, new[] { new NestPlateStock("stock", new Size(10, 10), 1) });
+        Assert.Throws<InvalidOperationException>(() => Solve(fixedJob, new NestJobPlacement("part", 0, 0, 0, 0)));
+
+        var fixedResult = Solve(fixedJob, new NestJobPlacement("part", 0, 2, 0, System.Math.PI / 2));
+        Assert.Equal(NestJobStatus.Complete, fixedResult.Status);
+
+        var boundedPart = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 2)), 1,
+            rotation: RotationPolicy.BoundedSweep(0, System.Math.PI / 2, System.Math.PI / 4));
+        var boundedJob = new NestJob(new[] { boundedPart }, new[] { new NestPlateStock("stock", new Size(10, 10), 1) });
+        Assert.Throws<InvalidOperationException>(() => Solve(boundedJob,
+            new NestJobPlacement("part", 0, 2, 0, System.Math.PI / 3)));
+
+        var boundedResult = Solve(boundedJob, new NestJobPlacement("part", 0, 2, 0, System.Math.PI / 4));
+        Assert.Equal(NestJobStatus.Complete, boundedResult.Status);
+    }
+
+    [Fact]
+    public void EdgeTouchingIsAllowedAtZeroSpacingAndRejectedAtPositiveSpacing()
+    {
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)), 2);
+        var touching = new[]
+        {
+            new NestJobPlacement("part", 0, 0, 0, 0),
+            new NestJobPlacement("part", 1, 2, 0, 0)
+        };
+        var zeroSpacing = new NestJob(new[] { part }, new[] { new NestPlateStock("stock", new Size(10, 10), 1) });
+        var positiveSpacing = new NestJob(new[] { part }, new[] { new NestPlateStock("stock", new Size(10, 10), 1, 0.1) });
+
+        Assert.Equal(NestJobStatus.Complete, Solve(zeroSpacing, touching).Status);
+        Assert.Throws<InvalidOperationException>(() => Solve(positiveSpacing, touching));
+    }
+
+    [Fact]
+    public void OverlapAndContainmentAreRejected()
+    {
+        var outer = new NestJobPart("outer", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(6, 6)), 1);
+        var inner = new NestJobPart("inner", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)), 1);
+        var job = new NestJob(new[] { outer, inner }, new[] { new NestPlateStock("stock", new Size(20, 20), 1) });
+
+        Assert.Throws<InvalidOperationException>(() => Solve(job,
+            new NestJobPlacement("outer", 0, 0, 0, 0),
+            new NestJobPlacement("inner", 0, 2, 2, 0)));
+    }
+
+    [Fact]
+    public void EmptyStockStopsWithoutCallingCandidateNester()
+    {
+        var nester = new CountingNester();
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)), 1);
+        var job = new NestJob(new[] { part }, Array.Empty<NestPlateStock>());
+
+        var result = new NestJobRunner(_ => nester).Solve(job);
+
+        Assert.Equal(NestJobStopReason.StockExhausted, result.StopReason);
+        Assert.Equal(0, nester.Calls);
+    }
+
+    [Theory]
+    [InlineData("Default")]
+    [InlineData("Strip")]
+    public void RealEngineSmokeCasesPreserveInputAndProduceSafeAccounting(string strategy)
+    {
+        var drawing = new Drawing("generated rectangle", TestDrawingFactory.Rectangle(6, 4));
+        var part = DrawingJobMapper.FromDrawing("part", drawing, 3);
+        var sourceGeometry = part.Geometry.Motions.ToArray();
+        var stock = new NestPlateStock("stock", new Size(30, 50), 1, 1, new Spacing(1, 1, 1, 1));
+        var job = new NestJob(new[] { part }, new[] { stock }, new NestJobOptions(strategy));
+
+        var result = new NestJobRunner(PlateNesterFactory.Create).Solve(job);
+        var materialized = NestResultMaterializer.Materialize(job, result);
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.All(result.Fulfillment, fulfillment => Assert.Equal(fulfillment.Requested,
+            fulfillment.Placed + fulfillment.Unplaced));
+        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
+        Assert.Equal(3, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+        Assert.All(materialized.Nest.Plates, plate =>
+        {
+            var workArea = plate.WorkArea();
+            Assert.All(plate.Parts, placed =>
+            {
+                Assert.True(placed.BoundingBox.Left >= workArea.Left - 1e-6);
+                Assert.True(placed.BoundingBox.Right <= workArea.Right + 1e-6);
+                Assert.True(placed.BoundingBox.Bottom >= workArea.Bottom - 1e-6);
+                Assert.True(placed.BoundingBox.Top <= workArea.Top + 1e-6);
+            });
+            for (var left = 0; left < plate.Parts.Count; left++)
+                for (var right = left + 1; right < plate.Parts.Count; right++)
+                    Assert.False(plate.Parts[left].Intersects(plate.Parts[right], out _));
+        });
+    }
+
+    private static NestJobResult Solve(NestJob job, params NestJobPlacement[] placements) =>
+        new NestJobRunner(_ => new CandidateNester(placements)).Solve(job);
+
+    private sealed class CandidateNester(IEnumerable<NestJobPlacement> placements) : IPlateNester
+    {
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default) => new(placements);
+    }
+
+    private sealed class CountingNester : IPlateNester
+    {
+        public int Calls { get; private set; }
+
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default)
+        {
+            Calls++;
+            return new PlateCandidate(Array.Empty<NestJobPlacement>());
+        }
+    }
+}

OpenNest.Engine.Tests/Jobs/NestJobIdentityTests.cs

@@ -0,0 +1,149 @@
+using OpenNest.CNC;
+using OpenNest.Engine.Fill;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+/// <summary>
+/// Names are never identity: two distinct drawings that share a display name must keep
+/// independent quantities, and two requirements that share one source drawing must not
+/// cross-count each other's placements through the legacy engine paths.
+/// </summary>
+public class NestJobIdentityTests
+{
+    [Fact]
+    public void DistinctDrawingsWithSameNameKeepIndependentQuantitiesInRealEngine()
+    {
+        var a = new Drawing("identical", TestDrawingFactory.Rectangle(40, 40));
+        var b = new Drawing("identical", TestDrawingFactory.Rectangle(40, 40));
+        var job = new NestJob(new[]
+        {
+            DrawingJobMapper.FromDrawing("a", a, 2),
+            DrawingJobMapper.FromDrawing("b", b, 2)
+        }, new[] { new NestPlateStock("s", new Size(90, 90), 1) });
+
+        var result = new NestJobRunner(LegacyPlateNesterAdapter.Create).Solve(job);
+
+        // Every placed part maps to a known requirement ID; no part is invented or cross-counted.
+        Assert.True(result.Plates.SelectMany(p => p.Placements).All(p => p.PartId is "a" or "b"));
+        var counts = result.Plates.SelectMany(p => p.Placements).GroupBy(p => p.PartId)
+            .ToDictionary(g => g.Key, g => g.Count());
+        foreach (var (id, placed) in counts)
+            Assert.True(placed <= 2, $"Requirement {id} placed {placed} > requested 2");
+
+        // Fulfillment conservation for both IDs.
+        foreach (var f in result.Fulfillment)
+            Assert.Equal(f.Requested, f.Placed + f.Unplaced);
+    }
+
+    [Fact]
+    public void TwoRequirementsOnSameSourceDrawingKeepIndependentQuantities()
+    {
+        var source = new Drawing("shared", TestDrawingFactory.Rectangle(30, 30));
+        var job = new NestJob(new[]
+        {
+            DrawingJobMapper.FromDrawing("first", source, 2),
+            DrawingJobMapper.FromDrawing("second", source, 2)
+        }, new[] { new NestPlateStock("s", new Size(90, 90), 1) });
+
+        var result = new NestJobRunner(LegacyPlateNesterAdapter.Create).Solve(job);
+
+        Assert.Equal(new[] { "first", "second" }, result.Fulfillment.Select(f => f.PartId));
+        foreach (var f in result.Fulfillment)
+            Assert.Equal(f.Requested, f.Placed + f.Unplaced);
+
+        // Output drawings are distinct even though the input is the same Drawing instance.
+        var output = NestResultMaterializer.Materialize(job, result);
+        Assert.NotSame(output.DrawingsByPartId["first"], output.DrawingsByPartId["second"]);
+        // Caller source is untouched.
+        Assert.Equal(0, source.Quantity.Nested);
+    }
+
+    [Fact]
+    public void EngineDeductionCountsByDrawingReferenceNotName()
+    {
+        // Plate 90x40 fits exactly two 40x40 parts. The engine fills item A with both and
+        // starves item B. Name-based deduction would then zero BOTH items (the two placed
+        // parts carry the shared name, so each item counts 2 as "its own"). Reference-based
+        // deduction leaves B at 2.
+        var a = new Drawing("dup", TestDrawingFactory.Rectangle(40, 40));
+        var b = new Drawing("dup", TestDrawingFactory.Rectangle(40, 40));
+        var plate = new Plate(new Size(90, 40));
+        var items = new List<NestItem>
+        {
+            new() { Drawing = a, Quantity = 2 },
+            new() { Drawing = b, Quantity = 2 }
+        };
+        // Place exactly 2 parts from item A and none from item B, then run the base-class
+        // deduction. Deterministic regardless of any fill heuristic.
+        var placed = new StarvingProbe(plate).Nest(items, null, default);
+
+        var aPlaced = placed.Count(p => ReferenceEquals(p.BaseDrawing, a));
+        var bPlaced = placed.Count(p => ReferenceEquals(p.BaseDrawing, b));
+        Assert.Equal(2, placed.Count);
+        Assert.Equal(2, aPlaced);
+        Assert.Equal(0, bPlaced);
+
+        // Invariant: remaining = requested - own placements. Under name-based counting,
+        // both items would read 0 here because the two placed parts match the shared name.
+        Assert.Equal(0, items[0].Quantity);
+        Assert.Equal(2, items[1].Quantity);
+    }
+
+    [Fact]
+    public void SameNameSinglesAreBothReturnedByPackPhase()
+    {
+        var a = new Drawing("samesingle", TestDrawingFactory.Rectangle(30, 30));
+        var b = new Drawing("samesingle", TestDrawingFactory.Rectangle(30, 30));
+        var plate = new Plate(new Size(100, 100));
+        var items = new List<NestItem>
+        {
+            new() { Drawing = a, Quantity = 1 },
+            new() { Drawing = b, Quantity = 1 }
+        };
+        var placed = new BaseNestEngineProbe(plate).Nest(items, null, default);
+        Assert.Equal(2, placed.Count);
+        Assert.Equal(new[] { 0, 0 }, new[] { items[0].Quantity, items[1].Quantity });
+    }
+
+    private sealed class BaseNestEngineProbe(Plate plate) : NestEngineBase(plate)
+    {
+        public override string Name => "probe";
+        public override string Description => "probe";
+        public override List<Part> Fill(NestItem item, Box workArea,
+            IProgress<NestProgress> progress, CancellationToken token)
+            => new DefaultNestEngine(Plate).Fill(item, workArea, progress, token);
+        public override List<Part> Fill(List<Part> groupParts, Box workArea,
+            IProgress<NestProgress> progress, CancellationToken token)
+            => new DefaultNestEngine(Plate).Fill(groupParts, workArea, progress, token);
+        public override List<Part> PackArea(Box box, List<NestItem> items,
+            IProgress<NestProgress> progress, CancellationToken token)
+            => new DefaultNestEngine(Plate).PackArea(box, items, progress, token);
+    }
+
+    /// <summary>Places exactly 2 parts from the first multi-quantity item and none from the
+    /// rest, forcing the base-class deduction to run on an asymmetric placement result.</summary>
+    private sealed class StarvingProbe(Plate plate) : NestEngineBase(plate)
+    {
+        private int _first = -1;
+        public override string Name => "starving";
+        public override string Description => "starves all but the first fill item";
+        public override List<Part> Fill(NestItem item, Box workArea,
+            IProgress<NestProgress> progress, CancellationToken token)
+        {
+            if (_first < 0) _first = 1;
+            if (_first++ != 1)
+                return new List<Part>();
+            var parts = new List<Part>();
+            var x = 0.0;
+            for (var i = 0; i < 2; i++)
+            {
+                var p = new Part(item.Drawing);
+                p.Offset(new Vector(x, 0));
+                x += item.Drawing.Program.BoundingBox().Width + Plate.PartSpacing;
+                parts.Add(p);
+            }
+            return parts;
+        }
+    }
+}

OpenNest.Engine.Tests/Jobs/NestJobRunnerTests.cs

@@ -0,0 +1,102 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestJobRunnerTests
+{
+    [Fact]
+    public void EmptyJobCompletesWithoutPlatesOrPlacementWork()
+    {
+        var fake = new FakePlateNester();
+        var factoryCalls = 0;
+        var runner = new NestJobRunner(_ => { factoryCalls++; return fake; });
+        var job = new NestJob(Array.Empty<NestJobPart>(), new[]
+        {
+            new NestPlateStock("finite", new Size(100, 200), 2),
+            new NestPlateStock("unlimited", new Size(100, 200))
+        });
+
+        var result = runner.Solve(job);
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(NestJobStopReason.Completed, result.StopReason);
+        Assert.Empty(result.Plates);
+        Assert.Empty(result.Fulfillment);
+        Assert.Collection(result.StockUsage,
+            usage => { Assert.Equal(0, usage.Used); Assert.Equal(2, usage.Remaining); },
+            usage => { Assert.Equal(0, usage.Used); Assert.Null(usage.Remaining); });
+        Assert.Equal(0, factoryCalls);
+        Assert.Equal(0, fake.Calls);
+    }
+
+    [Fact]
+    public void PreCancelledEmptyJobThrows()
+    {
+        using var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+        var runner = new NestJobRunner(_ => new FakePlateNester());
+        var job = new NestJob(Array.Empty<NestJobPart>(), Array.Empty<NestPlateStock>());
+        Assert.Throws<OperationCanceledException>(() => runner.Solve(job, token: cancellation.Token));
+    }
+
+    [Fact]
+    public void EmptyStockReturnsIncomplete()
+    {
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle()), 1);
+        var job = new NestJob(new[] { part }, Array.Empty<NestPlateStock>());
+        var runner = new NestJobRunner(_ => new FakePlateNester());
+        var result = runner.Solve(job);
+        Assert.Equal(NestJobStatus.Incomplete, result.Status);
+        Assert.Equal(NestJobStopReason.StockExhausted, result.StopReason);
+        Assert.Equal(1, Assert.Single(result.Fulfillment).Unplaced);
+    }
+
+    [Fact]
+    public void JobOwnsCollectionsSettingsAndExactGeometryIncludingHoleArc()
+    {
+        var program = TestDrawingFactory.Rectangle();
+        program.MoveTo(3.123456789, 4);
+        program.ArcTo(3.123456789, 4, 4, 4, RotationType.CW);
+        var geometry = PartGeometrySnapshot.FromProgram(program);
+        var parts = new List<NestJobPart> { new("p", geometry, 3) };
+        var size = new Size(100, 200);
+        var edges = new Spacing(1, 2, 3, 4);
+        var stocks = new List<NestPlateStock> { new("s", size, 0, 2, edges, 3) };
+        var job = new NestJob(parts, stocks);
+        parts.Clear(); stocks.Clear(); program.Codes.Clear(); size.Width = 0; edges.Left = 999;
+
+        Assert.Single(job.Parts);
+        Assert.Equal(3, job.Parts[0].Quantity);
+        Assert.Equal(7, geometry.Motions.Count);
+        Assert.Equal(CodeType.RapidMove, geometry.Motions[5].Type);
+        Assert.Equal(CodeType.ArcMove, geometry.Motions[6].Type);
+        Assert.Equal(3.123456789, geometry.Motions[6].X);
+        Assert.Equal(4, geometry.Motions[6].CenterX);
+        Assert.Equal(RotationType.CW, geometry.Motions[6].Rotation);
+        Assert.Equal(100, job.Plates[0].Size.Width);
+        Assert.Equal(1, job.Plates[0].EdgeSpacing.Left);
+        Assert.Equal(0, job.Plates[0].Quantity);
+        Assert.Equal("Default", job.Options.PlacementStrategy);
+        Assert.Throws<NotSupportedException>(() => ((IList<NestJobPart>)job.Parts).Clear());
+    }
+
+    [Fact]
+    public void LegacyZeroStepMeansAutomaticNotFixed()
+    {
+        Assert.Equal(RotationPolicyKind.Automatic, RotationPolicy.FromLegacy(0, 1, 2).Kind);
+        Assert.Equal(RotationPolicyKind.Fixed, RotationPolicy.Fixed(1).Kind);
+        Assert.Equal(RotationPolicyKind.BoundedSweep, RotationPolicy.BoundedSweep(0, 1, 0.5).Kind);
+    }
+
+    private sealed class FakePlateNester : IPlateNester
+    {
+        public int Calls { get; private set; }
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default)
+        {
+            Calls++;
+            return new PlateCandidate(Array.Empty<NestJobPlacement>());
+        }
+    }
+}

OpenNest.Engine.Tests/Jobs/NestJobStockSelectionTests.cs

@@ -0,0 +1,119 @@
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestJobStockSelectionTests
+{
+    [Fact]
+    public void LaterFittingStockWinsWhenFirstStockCannotPlace()
+    {
+        var result = Solve(new[] { Part("p", 1) }, new[] { Stock("small", 10, 10, 1), Stock("large", 20, 20, 1) },
+            request => request.Stock.Id == "large" ? Candidate(request, "p") : Empty());
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal("large", Assert.Single(result.Plates).StockId);
+    }
+
+    [Fact]
+    public void ExhaustedLargeStockIsNotRecreatedWhileSmallerStockServesSmallParts()
+    {
+        var result = Solve(new[] { Part("large", 1, 0), Part("small", 2, 1) },
+            new[] { Stock("large", 20, 20, 1), Stock("small", 10, 10, 2) }, request => request.Stock.Id switch
+            {
+                "large" when request.Parts.Any(part => part.Id == "large") => Candidate(request, "large"),
+                "small" when request.Parts.Any(part => part.Id == "small") => Candidate(request, "small"),
+                _ => Empty()
+            });
+
+        Assert.Equal(new[] { "large", "small", "small" }, result.Plates.Select(plate => plate.StockId));
+        Assert.Collection(result.StockUsage,
+            usage => Assert.Equal(new StockUsage("large", 1, 0), usage),
+            usage => Assert.Equal(new StockUsage("small", 2, 0), usage));
+    }
+
+    [Fact]
+    public void EqualDimensionsWithDifferentStockIdsRemainIndependent()
+    {
+        var result = Solve(new[] { Part("p", 2) }, new[] { Stock("first", 10, 10, 1), Stock("second", 10, 10, 1) },
+            request => Candidate(request, "p"));
+
+        Assert.Equal(new[] { "first", "second" }, result.Plates.Select(plate => plate.StockId));
+        Assert.Equal(new[] { new StockUsage("first", 1, 0), new StockUsage("second", 1, 0) }, result.StockUsage);
+    }
+
+    [Fact]
+    public void LosingTrialsDoNotConsumeStockPartsOrDrawingCounters()
+    {
+        var calls = new List<(string Stock, int Quantity)>();
+        var result = Solve(new[] { Part("p", 2) }, new[] { Stock("wide", 20, 20, 2), Stock("narrow", 10, 10, 2) }, request =>
+        {
+            calls.Add((request.Stock.Id, request.Parts.Single().Quantity));
+            return request.Stock.Id == "wide" ? Candidate(request, "p", 0, 100) : Candidate(request, "p", 0, 0);
+        });
+
+        Assert.Equal(new[] { "narrow", "narrow" }, result.Plates.Select(plate => plate.StockId));
+        Assert.Equal(new[] { ("wide", 2), ("narrow", 2), ("wide", 1), ("narrow", 1) }, calls);
+        Assert.Equal(new StockUsage("wide", 0, 2), result.StockUsage[0]);
+        Assert.Equal(new StockUsage("narrow", 2, 0), result.StockUsage[1]);
+        Assert.Equal(new[] { 0, 1 }, result.Plates.SelectMany(plate => plate.Placements).Select(placement => placement.InstanceIndex));
+    }
+
+    [Fact]
+    public void CandidatePriorityAreaEnvelopeAndInputOrderAreComparedInDocumentedOrder()
+    {
+        var priority = Solve(new[] { Part("high", 1, 0), Part("low", 1, 1) }, new[] { Stock("a", 10, 10, 1), Stock("b", 10, 10, 1) },
+            request => request.Stock.Id == "a" ? Candidate(request, "low") : Candidate(request, "high"));
+        var area = Solve(new[] { Part("p", 1) }, new[] { Stock("large", 20, 20, 1), Stock("small", 10, 10, 1) },
+            request => Candidate(request, "p"));
+        var envelope = Solve(new[] { Part("p", 2) }, new[] { Stock("a", 10, 10, 1), Stock("b", 10, 10, 1) },
+            request => request.Stock.Id == "a" ? CandidatePair("p", 4, 5) : CandidatePair("p", 4, 0));
+        var inputOrder = Solve(new[] { Part("p", 1) }, new[] { Stock("first", 10, 10, 1), Stock("second", 10, 10, 1) },
+            request => Candidate(request, "p"));
+
+        Assert.Equal("b", priority.Plates[0].StockId);
+        Assert.Equal("small", area.Plates[0].StockId);
+        Assert.Equal("b", envelope.Plates[0].StockId);
+        Assert.Equal("first", inputOrder.Plates[0].StockId);
+    }
+
+    [Fact]
+    public void UnlimitedStockStopsWhenDemandIsFulfilledAndPlateLimitLeavesLeftovers()
+    {
+        var unlimited = Solve(new[] { Part("p", 2) }, new[] { Stock("u", 10, 10, null) }, request => Candidate(request, "p"));
+        var limited = Solve(new[] { Part("p", 3) }, new[] { Stock("u", 10, 10, null) }, request => Candidate(request, "p"), new NestJobOptions(maxPlates: 2));
+
+        Assert.Equal(NestJobStopReason.Completed, unlimited.StopReason);
+        Assert.Equal(2, unlimited.Plates.Count);
+        Assert.Equal(NestJobStopReason.PlateLimitReached, limited.StopReason);
+        Assert.Equal(new PartFulfillment("p", 3, 2, 1), Assert.Single(limited.Fulfillment));
+    }
+
+    private static NestJobResult Solve(IEnumerable<NestJobPart> parts, IEnumerable<NestPlateStock> stock,
+        Func<PlatePlacementRequest, PlateCandidate> place, NestJobOptions? options = null) =>
+        new NestJobRunner(_ => new Nester(place)).Solve(new NestJob(parts, stock, options));
+
+    private static NestJobPart Part(string id, int quantity, int priority = 0) =>
+        new(id, PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 5)), quantity, priority);
+
+    private static NestPlateStock Stock(string id, double width, double length, int? quantity) =>
+        new(id, new Size(width, length), quantity);
+
+    private static PlateCandidate Candidate(PlatePlacementRequest request, string id, double firstX = 0, double secondX = 0)
+    {
+        return new PlateCandidate(new[] { new NestJobPlacement(id, 0, firstX, 0, 0) });
+    }
+
+    private static PlateCandidate CandidatePair(string id, double secondX, double secondY) => new(new[]
+    {
+        new NestJobPlacement(id, 0, 0, 0, 0),
+        new NestJobPlacement(id, 1, secondX, secondY, 0)
+    });
+
+    private static PlateCandidate Empty() => new(Array.Empty<NestJobPlacement>());
+
+    private sealed class Nester(Func<PlatePlacementRequest, PlateCandidate> place) : IPlateNester
+    {
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default) => place(request);
+    }
+}

OpenNest.Engine.Tests/Jobs/NestJobValidationTests.cs

@@ -0,0 +1,120 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestJobValidationTests
+{
+    [Fact]
+    public void IncrementalContoursUseAccumulatedCoordinates()
+    {
+        var program = new Program(Mode.Incremental);
+        program.MoveTo(0, 0);
+        program.LineTo(4, 0);
+        program.LineTo(0, 3);
+        program.LineTo(-4, 0);
+        program.LineTo(0, -3);
+        var job = new NestJob(new[]
+        {
+            new NestJobPart("part", PartGeometrySnapshot.FromProgram(program), 1)
+        }, new[] { new NestPlateStock("stock", new Size(10, 10), 1) });
+
+        var result = Solve(job, new NestJobPlacement("part", 0, 0, 0, 0));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(new PartFulfillment("part", 1, 1, 0), Assert.Single(result.Fulfillment));
+    }
+
+    [Fact]
+    public void CandidateInsideAnotherRequirementsHoleDoesNotOverlapMaterial()
+    {
+        var outer = new NestJobPart("outer", PartGeometrySnapshot.FromProgram(RectangleWithHole()), 1);
+        var inner = new NestJobPart("inner", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)), 1);
+        var job = new NestJob(new[] { outer, inner }, new[] { new NestPlateStock("stock", new Size(20, 20), 1) });
+
+        var result = Solve(job,
+            new NestJobPlacement("outer", 0, 0, 0, 0),
+            new NestJobPlacement("inner", 0, 4, 4, 0));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Single(result.Plates);
+        Assert.Equal(2, result.Plates[0].Placements.Count);
+    }
+
+    [Fact]
+    public void UnknownOrOverproducingCandidateFailsBeforeCommitWithoutChangingInput()
+    {
+        var reports = new List<NestJobProgress>();
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)), 1);
+        var stock = new NestPlateStock("stock", new Size(20, 20), 1);
+        var job = new NestJob(new[] { part }, new[] { stock });
+        var runner = new NestJobRunner(_ => new CandidateNester(new[]
+        {
+            new NestJobPlacement("part", 0, 0, 0, 0),
+            new NestJobPlacement("unknown", 0, 4, 0, 0)
+        }));
+
+        Assert.Throws<InvalidOperationException>(() => runner.Solve(job, new InlineProgress(reports.Add)));
+
+        Assert.Equal(1, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+        Assert.DoesNotContain(reports, report => report.Stage == NestJobStage.PlateCommitted);
+    }
+
+    [Fact]
+    public void CandidateThatOverproducesIsRejectedRatherThanClamped()
+    {
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(2, 2)), 1);
+        var job = new NestJob(new[] { part }, new[] { new NestPlateStock("stock", new Size(20, 20), 1) });
+
+        Assert.Throws<InvalidOperationException>(() => Solve(job,
+            new NestJobPlacement("part", 0, 0, 0, 0),
+            new NestJobPlacement("part", 1, 4, 0, 0)));
+
+        Assert.Equal(1, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void OpenOrZeroLengthContoursAreRejected(bool zeroLength)
+    {
+        var program = new Program();
+        program.MoveTo(0, 0);
+        program.LineTo(4, 0);
+        if (zeroLength) program.LineTo(4, 0);
+        program.LineTo(4, 3);
+        program.LineTo(0, 3);
+        if (zeroLength) program.LineTo(0, 0);
+        var job = new NestJob(new[] { new NestJobPart("part", PartGeometrySnapshot.FromProgram(program), 1) },
+            new[] { new NestPlateStock("stock", new Size(20, 20), 1) });
+
+        Assert.Throws<ArgumentException>(() => new NestJobRunner(_ => new CandidateNester(Array.Empty<NestJobPlacement>())).Solve(job));
+    }
+
+    private static NestJobResult Solve(NestJob job, params NestJobPlacement[] placements) =>
+        new NestJobRunner(_ => new CandidateNester(placements)).Solve(job);
+
+    private static Program RectangleWithHole()
+    {
+        var program = TestDrawingFactory.Rectangle(10, 10);
+        program.MoveTo(3, 3);
+        program.LineTo(3, 7);
+        program.LineTo(7, 7);
+        program.LineTo(7, 3);
+        program.LineTo(3, 3);
+        return program;
+    }
+
+    private sealed class CandidateNester(IEnumerable<NestJobPlacement> placements) : IPlateNester
+    {
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default) => new(placements);
+    }
+
+    private sealed class InlineProgress(Action<NestJobProgress> report) : IProgress<NestJobProgress>
+    {
+        public void Report(NestJobProgress value) => report(value);
+    }
+}

OpenNest.Engine.Tests/Jobs/PlateNesterParityTests.cs

@@ -0,0 +1,257 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using Xunit;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+/// <summary>
+/// Parity between the legacy adapter and the migrated built-in plate nesters (Default/Strip) on
+/// generated geometry. The runner's placement validator enforces geometric safety on every committed
+/// candidate, so these tests assert fulfillment, status, and — for the deterministic Default/rectangle
+/// case — identical layouts.
+/// </summary>
+public class PlateNesterParityTests
+{
+    private const double Tolerance = 1e-6;
+
+    private static readonly Size PlateSize = new(30, 50);
+    private static readonly Spacing Edge = new(1, 1, 1, 1);
+
+    private static NestJob Job(IReadOnlyList<NestJobPart> parts, int? stockQuantity = 3,
+        string strategy = "Default")
+    {
+        var stock = new NestPlateStock("stock", PlateSize, stockQuantity, 1, Edge);
+        return new NestJob(parts, new[] { stock }, new NestJobOptions(strategy));
+    }
+
+    private static NestJobResult Solve(IPlateNester nester, NestJob job) =>
+        new NestJobRunner(_ => nester).Solve(job);
+
+    private static Dictionary<string, PartFulfillment> ByPart(NestJobResult result) =>
+        result.Fulfillment.ToDictionary(f => f.PartId, StringComparer.Ordinal);
+
+    private static void AssertLayoutsIdentical(NestJobResult left, NestJobResult right)
+    {
+        Assert.Equal(left.Plates.Count, right.Plates.Count);
+        for (var i = 0; i < left.Plates.Count; i++)
+        {
+            var lPlates = left.Plates[i].Placements;
+            var rPlates = right.Plates[i].Placements;
+            Assert.Equal(lPlates.Count, rPlates.Count);
+            var lSorted = lPlates.OrderBy(p => p.PartId).ThenBy(p => p.X).ThenBy(p => p.Y).ToList();
+            var rSorted = rPlates.OrderBy(p => p.PartId).ThenBy(p => p.X).ThenBy(p => p.Y).ToList();
+            for (var j = 0; j < lSorted.Count; j++)
+            {
+                Assert.Equal(lSorted[j].PartId, rSorted[j].PartId);
+                Assert.Equal(lSorted[j].X, rSorted[j].X, 6);
+                Assert.Equal(lSorted[j].Y, rSorted[j].Y, 6);
+                Assert.True(AnglesEqual(lSorted[j].Rotation, rSorted[j].Rotation),
+                    $"rotation differs: {lSorted[j].Rotation} vs {rSorted[j].Rotation}");
+            }
+        }
+    }
+
+    private static bool AnglesEqual(double left, double right)
+    {
+        var delta = (left - right) % (System.Math.PI * 2);
+        return System.Math.Abs(delta) <= Tolerance ||
+            System.Math.Abs(System.Math.Abs(delta) - System.Math.PI * 2) <= Tolerance;
+    }
+
+    [Fact]
+    public void DefaultParity_Rectangles_SameFulfillmentAndLayout()
+    {
+        var parts = new[]
+        {
+            new NestJobPart("a", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(6, 4)), 4),
+            new NestJobPart("b", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 3)
+        };
+
+        var legacy = Solve(new LegacyPlateNesterAdapter(plate => new DefaultNestEngine(plate)), Job(parts));
+        var migrated = Solve(new DefaultPlateNester(), Job(parts));
+
+        Assert.Equal(legacy.Status, migrated.Status);
+        Assert.Equal(NestJobStatus.Complete, migrated.Status);
+        Assert.Equal(ByPart(legacy), ByPart(migrated));
+        foreach (var usage in legacy.StockUsage)
+            Assert.Equal(usage.Used, migrated.StockUsage.First(u => u.StockId == usage.StockId).Used);
+        // Automatic-rotation rectangles on a single stock size are deterministic: identical layouts.
+        AssertLayoutsIdentical(legacy, migrated);
+    }
+
+    [Fact]
+    public void StripParity_Rectangles_SameFulfillmentAndTotalCount()
+    {
+        var parts = new[]
+        {
+            new NestJobPart("a", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(6, 4)), 4),
+            new NestJobPart("b", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 3)
+        };
+
+        var legacy = Solve(new LegacyPlateNesterAdapter(plate => new StripNestEngine(plate)),
+            Job(parts, strategy: "Strip"));
+        var migrated = Solve(new StripPlateNester(), Job(parts, strategy: "Strip"));
+
+        Assert.Equal(legacy.Status, migrated.Status);
+        Assert.Equal(NestJobStatus.Complete, migrated.Status);
+        Assert.Equal(ByPart(legacy), ByPart(migrated));
+        Assert.Equal(legacy.Plates.SelectMany(p => p.Placements).Count(),
+            migrated.Plates.SelectMany(p => p.Placements).Count());
+        // Shrink-fill ordering can differ between engine instances; do not assert identical coordinates.
+    }
+
+    [Fact]
+    public void MigratedBuiltins_AreResolvedByProductionFactory()
+    {
+        Assert.IsType<DefaultPlateNester>(PlateNesterFactory.Create("Default"));
+        Assert.IsType<StripPlateNester>(PlateNesterFactory.Create("Strip"));
+        Assert.IsType<LegacyPlateNesterAdapter>(PlateNesterFactory.Create("Vertical Remnant"));
+        Assert.IsType<LegacyPlateNesterAdapter>(PlateNesterFactory.Create("Horizontal Remnant"));
+    }
+
+    [Fact]
+    public void AsymmetricPart_ValidAndFulfilled()
+    {
+        // L-shape: 6x4 outer with a corner notch removed (single closed contour, asymmetric).
+        var lshape = new Program();
+        lshape.MoveTo(0, 0);
+        lshape.LineTo(6, 0);
+        lshape.LineTo(6, 4);
+        lshape.LineTo(3, 4);
+        lshape.LineTo(3, 2);
+        lshape.LineTo(0, 2);
+        lshape.LineTo(0, 0);
+
+        var parts = new[]
+        {
+            new NestJobPart("l", PartGeometrySnapshot.FromProgram(lshape), 3),
+            new NestJobPart("sq", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 2)
+        };
+        var result = Solve(new DefaultPlateNester(), Job(parts));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(3, ByPart(result)["l"].Placed);
+        Assert.Equal(2, ByPart(result)["sq"].Placed);
+        Assert.Equal(5, result.Plates.SelectMany(p => p.Placements).Count());
+    }
+
+    [Fact]
+    public void HoleAndArcParts_ValidAndFulfilled()
+    {
+        // 6x6 rectangle with a 2x2 inner hole (rapid contour), plus a D-shape with a semicircular arc.
+        var holed = new Program();
+        holed.MoveTo(0, 0);
+        holed.LineTo(6, 0);
+        holed.LineTo(6, 6);
+        holed.LineTo(0, 6);
+        holed.LineTo(0, 0);
+        holed.MoveTo(2, 2);
+        holed.LineTo(4, 2);
+        holed.LineTo(4, 4);
+        holed.LineTo(2, 4);
+        holed.LineTo(2, 2);
+
+        var arc = new Program();
+        arc.MoveTo(0, 0);
+        arc.LineTo(3, 0);
+        arc.ArcTo(3, 5, 3, 2.5, RotationType.CCW);
+        arc.LineTo(0, 5);
+        arc.LineTo(0, 0);
+
+        var parts = new[]
+        {
+            new NestJobPart("holed", PartGeometrySnapshot.FromProgram(holed), 2),
+            new NestJobPart("arc", PartGeometrySnapshot.FromProgram(arc), 2)
+        };
+        var result = Solve(new DefaultPlateNester(), Job(parts));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(2, ByPart(result)["holed"].Placed);
+        Assert.Equal(2, ByPart(result)["arc"].Placed);
+    }
+
+    [Fact]
+    public void FixedRotation_Respected()
+    {
+        var part = new NestJobPart("fixed", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(6, 4)),
+            2, rotation: RotationPolicy.Fixed(0));
+        var result = Solve(new DefaultPlateNester(), Job(new[] { part }));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        var placements = result.Plates.SelectMany(p => p.Placements).ToList();
+        Assert.Equal(2, placements.Count);
+        foreach (var placement in placements)
+            Assert.True(AnglesEqual(placement.Rotation, 0), $"fixed rotation violated: {placement.Rotation}");
+    }
+
+    [Fact]
+    public void RepeatedNames_KeepIndependentIdentity()
+    {
+        // Two distinct requirements sharing identical geometry (and, via the mapper, name) but different IDs.
+        var program = TestDrawingFactory.Rectangle(6, 4);
+        var parts = new[]
+        {
+            new NestJobPart("first", PartGeometrySnapshot.FromProgram(program), 2),
+            new NestJobPart("second", PartGeometrySnapshot.FromProgram(program), 1)
+        };
+        var result = Solve(new DefaultPlateNester(), Job(parts));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(2, ByPart(result)["first"].Placed);
+        Assert.Equal(1, ByPart(result)["second"].Placed);
+        var ids = result.Plates.SelectMany(p => p.Placements).Select(p => p.PartId);
+        Assert.Equal(2, ids.Count(id => id == "first"));
+        Assert.Equal(1, ids.Count(id => id == "second"));
+    }
+
+    [Fact]
+    public void OffsetGeometry_ValidAndFulfilled()
+    {
+        // Part contour starting at a nonzero origin (offset geometry).
+        var program = new Program();
+        program.MoveTo(12, 7);
+        program.LineTo(18, 7);
+        program.LineTo(18, 11);
+        program.LineTo(12, 11);
+        program.LineTo(12, 7);
+
+        var part = new NestJobPart("offset", PartGeometrySnapshot.FromProgram(program), 2);
+        var result = Solve(new DefaultPlateNester(), Job(new[] { part }));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(2, ByPart(result)["offset"].Placed);
+        // The runner's validator guarantees containment and non-overlap for every committed placement.
+    }
+
+    [Fact]
+    public void RunScopedCache_DrawingReusedAcrossTrials()
+    {
+        // 14x9 parts on 30x20: one sheet holds fewer than five, so the runner runs multiple candidate
+        // trials through the same nester instance. The run-scoped drawing cache must keep producing
+        // valid, correctly-attributed placements across trials.
+        var part = new NestJobPart("p", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(14, 9)), 5);
+        var stock = new NestPlateStock("stock", new Size(30, 20), 3);
+        var nester = new DefaultPlateNester();
+        var result = new NestJobRunner(_ => nester).Solve(new NestJob(new[] { part }, new[] { stock }));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(5, result.Fulfillment.Single(f => f.PartId == "p").Placed);
+        Assert.Equal(2, result.Plates.Count);
+        var usage = result.StockUsage.Single();
+        Assert.Equal(2, usage.Used);
+        Assert.Equal(1, usage.Remaining);
+    }
+
+    [Fact]
+    public void LegacyRemnantStrategies_StillResolveThroughAdapter()
+    {
+        // Remnant strategies must keep working through the legacy adapter after the factory change.
+        var part = new NestJobPart("p", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(6, 4)), 2);
+        foreach (var strategy in new[] { "Vertical Remnant", "Horizontal Remnant" })
+        {
+            var result = Solve(PlateNesterFactory.Create(strategy), Job(new[] { part }, strategy: strategy));
+            Assert.Equal(NestJobStatus.Complete, result.Status);
+            Assert.Equal(2, result.Fulfillment.Single(f => f.PartId == "p").Placed);
+        }
+    }
+}

OpenNest.Engine.Tests/Jobs/TestDrawingFactory.cs

@@ -0,0 +1,17 @@
+using OpenNest.CNC;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+internal static class TestDrawingFactory
+{
+    public static Program Rectangle(double width = 10, double length = 20)
+    {
+        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;
+    }
+}

OpenNest.Engine.Tests/OpenNest.Engine.Tests.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</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" />
+  </ItemGroup>
+  <ItemGroup>
+    <Using Include="Xunit" />
+    <ProjectReference Include="../OpenNest.Engine/OpenNest.Engine.csproj" />
+  </ItemGroup>
+</Project>

OpenNest.Engine/BestFit/BestFitCache.cs

@@ -24,6 +24,9 @@ namespace OpenNest.Engine.BestFit
             if (_cache.TryGetValue(key, out var cached))
                 return cached;
 
+            // Operate on the canonical frame so cached pair positions are orientation-invariant.
+            var canonical = CanonicalFrame.AsCanonicalCopy(drawing);
+
             IPairEvaluator evaluator = null;
             ISlideComputer slideComputer = null;
 
@@ -31,7 +34,7 @@ namespace OpenNest.Engine.BestFit
             {
                 if (CreateEvaluator != null)
                 {
-                    try { evaluator = CreateEvaluator(drawing, spacing); }
+                    try { evaluator = CreateEvaluator(canonical, spacing); }
                     catch { /* fall back to default evaluator */ }
                 }
 
@@ -42,7 +45,7 @@ namespace OpenNest.Engine.BestFit
                 }
 
                 var finder = new BestFitFinder(plateWidth, plateHeight, evaluator, slideComputer);
-                var results = finder.FindBestFits(drawing, spacing, StepSize);
+                var results = finder.FindBestFits(canonical, spacing, StepSize);
 
                 _cache.TryAdd(key, results);
                 return results;
@@ -86,9 +89,12 @@ namespace OpenNest.Engine.BestFit
 
             try
             {
+                // Operate on the canonical frame so cached pair positions are orientation-invariant.
+                var canonical = CanonicalFrame.AsCanonicalCopy(drawing);
+
                 if (CreateEvaluator != null)
                 {
-                    try { evaluator = CreateEvaluator(drawing, spacing); }
+                    try { evaluator = CreateEvaluator(canonical, spacing); }
                     catch { /* fall back to default evaluator */ }
                 }
 
@@ -100,7 +106,7 @@ namespace OpenNest.Engine.BestFit
 
                 // Compute candidates and evaluate once with the largest plate.
                 var finder = new BestFitFinder(maxWidth, maxHeight, evaluator, slideComputer);
-                var baseResults = finder.FindBestFits(drawing, spacing, StepSize);
+                var baseResults = finder.FindBestFits(canonical, spacing, StepSize);
 
                 // Cache a filtered copy for each plate size.
                 foreach (var size in needed)

OpenNest.Engine/BestFit/BestFitResult.cs

@@ -1,6 +1,9 @@
+using OpenNest.Engine;
+using OpenNest.Converters;
 using OpenNest.Geometry;
 using OpenNest.Math;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace OpenNest.Engine.BestFit
 {
@@ -54,6 +57,68 @@ namespace OpenNest.Engine.BestFit
 
             return new List<Part> { part1, part2 };
         }
+
+        public List<Part> BuildCanonicalParts()
+        {
+            return NormalizeToCutOrigin(BuildParts(Candidate.Drawing));
+        }
+
+        public List<Part> BuildSourceParts(Drawing drawing)
+        {
+            var parts = BuildCanonicalParts();
+            var sourceAngle = drawing?.Source?.Angle ?? 0.0;
+
+            for (var i = 0; i < parts.Count; i++)
+            {
+                var p = parts[i];
+                var rebound = Part.CreateAtOrigin(drawing, p.Rotation);
+                var delta = p.BoundingBox.Location - rebound.BoundingBox.Location;
+                rebound.Offset(delta);
+                rebound.UpdateBounds();
+                parts[i] = rebound;
+            }
+
+            return NormalizeToCutOrigin(CanonicalFrame.FromCanonical(parts, sourceAngle));
+        }
+
+        public Box GetCutBounds(List<Part> parts)
+        {
+            return GetCutBoundingBox(parts);
+        }
+
+        private static List<Part> NormalizeToCutOrigin(List<Part> parts)
+        {
+            if (parts == null || parts.Count == 0)
+                return parts;
+
+            var bounds = GetCutBoundingBox(parts);
+            var offset = new Vector(-bounds.Left, -bounds.Bottom);
+
+            foreach (var part in parts)
+                part.Offset(offset);
+
+            return parts;
+        }
+
+        private static Box GetCutBoundingBox(List<Part> parts)
+        {
+            var entities = new List<IBoundable>();
+
+            foreach (var part in parts)
+            {
+                var partEntities = ConvertProgram.ToGeometry(part.Program)
+                    .Where(e => e.Layer != SpecialLayers.Rapid)
+                    .ToList();
+
+                foreach (var entity in partEntities)
+                {
+                    entity.Offset(part.Location);
+                    entities.Add(entity);
+                }
+            }
+
+            return entities.GetBoundingBox();
+        }
     }
 
     public enum BestFitSortField

OpenNest.Engine/BestFit/NfpSlideStrategy.cs

@@ -1,18 +1,10 @@
 using OpenNest.Geometry;
-using OpenNest.Math;
 using System.Collections.Generic;
-using System.IO;
 
 namespace OpenNest.Engine.BestFit
 {
     public class NfpSlideStrategy : IBestFitStrategy
     {
-        private static readonly string LogPath = Path.Combine(
-            System.Environment.GetFolderPath(System.Environment.SpecialFolder.Desktop),
-            "nfp-slide-debug.log");
-
-        private static readonly object LogLock = new object();
-
         private readonly double _part2Rotation;
         private readonly Polygon _stationaryPerimeter;
         private readonly Polygon _stationaryHull;
@@ -46,12 +38,6 @@ namespace OpenNest.Engine.BestFit
 
             var hull = ConvexHull.Compute(result.Polygon.Vertices);
 
-            Log($"=== Create: drawing={drawing.Name}, rotation={Angle.ToDegrees(part2Rotation):F1}deg ===");
-            Log($"  Perimeter: {result.Polygon.Vertices.Count} verts, bounds={FormatBounds(result.Polygon)}");
-            Log($"  Hull: {hull.Vertices.Count} verts, bounds={FormatBounds(hull)}");
-            Log($"  Correction: ({result.Correction.X:F4}, {result.Correction.Y:F4})");
-            Log($"  ProgramBBox: {drawing.Program.BoundingBox()}");
-
             return new NfpSlideStrategy(part2Rotation, type, description,
                 result.Polygon, hull, result.Correction);
         }
@@ -63,40 +49,17 @@ namespace OpenNest.Engine.BestFit
             if (stepSize <= 0)
                 return candidates;
 
-            Log($"--- GenerateCandidates: drawing={drawing.Name}, part2Rot={Angle.ToDegrees(_part2Rotation):F1}deg, spacing={spacing}, stepSize={stepSize} ---");
-
-            // Orbiting polygon: same shape rotated to Part2's angle.
             var orbitingPerimeter = PolygonHelper.RotatePolygon(_stationaryPerimeter, _part2Rotation, reNormalize: true);
             var orbitingPoly = ConvexHull.Compute(orbitingPerimeter.Vertices);
 
-            Log($"  Stationary hull: {_stationaryHull.Vertices.Count} verts, bounds={FormatBounds(_stationaryHull)}");
-            Log($"  Orbiting perimeter (rotated): {orbitingPerimeter.Vertices.Count} verts, bounds={FormatBounds(orbitingPerimeter)}");
-            Log($"  Orbiting hull: {orbitingPoly.Vertices.Count} verts, bounds={FormatBounds(orbitingPoly)}");
-
             var nfp = NoFitPolygon.ComputeConvex(_stationaryHull, orbitingPoly);
 
             if (nfp == null || nfp.Vertices.Count < 3)
-            {
-                Log($"  NFP failed or degenerate (verts={nfp?.Vertices.Count ?? 0})");
                 return candidates;
-            }
 
             var verts = nfp.Vertices;
             var vertCount = nfp.IsClosed() ? verts.Count - 1 : verts.Count;
 
-            Log($"  NFP: {verts.Count} verts (closed={nfp.IsClosed()}, walking {vertCount}), bounds={FormatBounds(nfp)}");
-            Log($"  Correction: ({_correction.X:F4}, {_correction.Y:F4})");
-
-            // Log NFP vertices
-            for (var v = 0; v < vertCount; v++)
-                Log($"    NFP vert[{v}]: ({verts[v].X:F4}, {verts[v].Y:F4}) -> corrected: ({verts[v].X - _correction.X:F4}, {verts[v].Y - _correction.Y:F4})");
-
-            // Compare with what RotationSlideStrategy would produce
-            var part1 = Part.CreateAtOrigin(drawing);
-            var part2 = Part.CreateAtOrigin(drawing, _part2Rotation);
-            Log($"  Part1 (rot=0): loc=({part1.Location.X:F4}, {part1.Location.Y:F4}), bbox={part1.BoundingBox}");
-            Log($"  Part2 (rot={Angle.ToDegrees(_part2Rotation):F1}): loc=({part2.Location.X:F4}, {part2.Location.Y:F4}), bbox={part2.BoundingBox}");
-
             var testNumber = 0;
 
             for (var i = 0; i < vertCount; i++)
@@ -125,20 +88,6 @@ namespace OpenNest.Engine.BestFit
                 }
             }
 
-            // Log overlap check for vertex candidates (first few)
-            var checkCount = System.Math.Min(vertCount, 8);
-            for (var c = 0; c < checkCount; c++)
-            {
-                var cand = candidates[c];
-                var p2 = Part.CreateAtOrigin(drawing, cand.Part2Rotation);
-                p2.Location = cand.Part2Offset;
-                var overlaps = part1.Intersects(p2, out _);
-                Log($"  Candidate[{c}]: offset=({cand.Part2Offset.X:F4}, {cand.Part2Offset.Y:F4}), overlaps={overlaps}");
-            }
-
-            Log($"  Total candidates: {candidates.Count}");
-            Log("");
-
             return candidates;
         }
 
@@ -160,20 +109,5 @@ namespace OpenNest.Engine.BestFit
                 Spacing = spacing
             };
         }
-
-        private static string FormatBounds(Polygon polygon)
-        {
-            polygon.UpdateBounds();
-            var bb = polygon.BoundingBox;
-            return $"[({bb.Left:F4}, {bb.Bottom:F4})-({bb.Right:F4}, {bb.Top:F4}), {bb.Width:F2}x{bb.Length:F2}]";
-        }
-
-        private static void Log(string message)
-        {
-            lock (LogLock)
-            {
-                File.AppendAllText(LogPath, message + "\n");
-            }
-        }
     }
 }

OpenNest.Engine/CanonicalFrame.cs

@@ -0,0 +1,76 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using OpenNest.Math;
+using System.Collections.Generic;
+
+namespace OpenNest.Engine
+{
+    /// <summary>
+    /// Produces transient canonical (MBR-axis-aligned) copies of drawings for engine consumption
+    /// and un-rotates placed parts back to the drawing's original frame.
+    /// </summary>
+    public static class CanonicalFrame
+    {
+        /// <summary>
+        /// Returns a new Drawing whose Program geometry is rotated to the canonical frame.
+        /// The source drawing is not mutated.
+        /// </summary>
+        public static Drawing AsCanonicalCopy(Drawing drawing)
+        {
+            if (drawing == null)
+                return null;
+
+            var angle = drawing.Source?.Angle ?? 0.0;
+
+            // Clone program (never mutate the source).
+            var pgm = (drawing.Program.Clone() as OpenNest.CNC.Program)
+                      ?? new OpenNest.CNC.Program();
+
+            if (!Tolerance.IsEqualTo(angle, 0))
+                pgm.Rotate(angle, pgm.BoundingBox().Center);
+
+            var copy = new Drawing(drawing.Name ?? string.Empty, pgm)
+            {
+                Color = drawing.Color,
+                Constraints = drawing.Constraints,
+                Material = drawing.Material,
+                Priority = drawing.Priority,
+                Customer = drawing.Customer,
+                IsCutOff = drawing.IsCutOff,
+                Source = new SourceInfo
+                {
+                    Path = drawing.Source?.Path,
+                    Offset = drawing.Source?.Offset ?? new Vector(0, 0),
+                    Angle = 0.0,
+                },
+            };
+            return copy;
+        }
+
+        /// <summary>
+        /// Composes the source drawing's canonical angle onto each placed part so the
+        /// returned list is in the drawing's original (visible) frame.
+        ///
+        /// Derivation: let sourceAngle = S (rotation mapping source -> canonical).
+        /// Canonical part at rotation R shows visible orientation R.
+        /// Source part at rotation R' shows visible orientation R' + (-S), because the
+        /// source geometry is already rotated by -S relative to canonical.
+        /// Setting equal gives R' = R + S, so we ADD sourceAngle to each placed part.
+        ///
+        /// Rotation is performed around the part's Location so its placement position is preserved;
+        /// only the orientation composes.
+        /// </summary>
+        public static List<Part> FromCanonical(List<Part> placed, double sourceAngle)
+        {
+            if (placed == null || placed.Count == 0)
+                return placed;
+            if (Tolerance.IsEqualTo(sourceAngle, 0))
+                return placed;
+
+            foreach (var p in placed)
+                p.Rotate(sourceAngle, p.Location);
+
+            return placed;
+        }
+    }
+}

OpenNest.Engine/DefaultNestEngine.cs

@@ -47,14 +47,29 @@ namespace OpenNest
             PhaseResults.Clear();
             AngleResults.Clear();
 
-            // Fast path: for very small quantities, skip the full strategy pipeline.
-            if (item.Quantity > 0 && item.Quantity <= 2)
+            // Replace the item's Drawing with a canonical copy for the duration of this fill.
+            // All internal methods see canonical geometry; this wrapper un-canonicalizes the final result.
+            var sourceAngle = item.Drawing?.Source?.Angle ?? 0.0;
+            var originalDrawing = item.Drawing;
+            var canonicalItem = new NestItem
             {
-                var fast = TryFillSmallQuantity(item, workArea);
-                if (fast != null && fast.Count >= item.Quantity)
+                Drawing = CanonicalFrame.AsCanonicalCopy(item.Drawing),
+                Quantity = item.Quantity,
+                Priority = item.Priority,
+                RotationStart = item.RotationStart,
+                RotationEnd = item.RotationEnd,
+                StepAngle = item.StepAngle,
+            };
+
+            // Fast path for qty 1-2.
+            if (canonicalItem.Quantity > 0 && canonicalItem.Quantity <= 2)
+            {
+                var fast = TryFillSmallQuantity(canonicalItem, workArea);
+                if (fast != null && fast.Count >= canonicalItem.Quantity)
                 {
-                    Debug.WriteLine($"[Fill] Fast path: placed {fast.Count} parts for qty={item.Quantity}");
+                    Debug.WriteLine($"[Fill] Fast path: placed {fast.Count} parts for qty={canonicalItem.Quantity}");
                     WinnerPhase = NestPhase.Pairs;
+                    fast = RebindAndUnCanonicalize(fast, originalDrawing, sourceAngle);
                     ReportProgress(progress, new ProgressReport
                     {
                         Phase = WinnerPhase,
@@ -68,32 +83,30 @@ namespace OpenNest
                 }
             }
 
-            // For low quantities, shrink the work area in both dimensions to avoid
-            // running expensive strategies against the full plate.
             var effectiveWorkArea = workArea;
-            if (item.Quantity > 0)
+            if (canonicalItem.Quantity > 0)
             {
-                effectiveWorkArea = ShrinkWorkArea(item, workArea, Plate.PartSpacing);
-
+                effectiveWorkArea = ShrinkWorkArea(canonicalItem, workArea, Plate.PartSpacing);
                 if (effectiveWorkArea != workArea)
-                    Debug.WriteLine($"[Fill] Low-qty shrink: {item.Quantity} requested, " +
+                    Debug.WriteLine($"[Fill] Low-qty shrink: {canonicalItem.Quantity} requested, " +
                         $"from {workArea.Width:F1}x{workArea.Length:F1} " +
                         $"to {effectiveWorkArea.Width:F1}x{effectiveWorkArea.Length:F1}");
             }
 
-            var best = RunFillPipeline(item, effectiveWorkArea, progress, token);
+            var best = RunFillPipeline(canonicalItem, effectiveWorkArea, progress, token);
 
-            // Fallback: if the reduced area didn't yield enough, retry with full area.
-            if (item.Quantity > 0 && best.Count < item.Quantity && effectiveWorkArea != workArea)
+            if (canonicalItem.Quantity > 0 && best.Count < canonicalItem.Quantity && effectiveWorkArea != workArea)
             {
-                Debug.WriteLine($"[Fill] Low-qty fallback: got {best.Count}, need {item.Quantity}, retrying full area");
+                Debug.WriteLine($"[Fill] Low-qty fallback: got {best.Count}, need {canonicalItem.Quantity}, retrying full area");
                 PhaseResults.Clear();
                 AngleResults.Clear();
-                best = RunFillPipeline(item, workArea, progress, token);
+                best = RunFillPipeline(canonicalItem, workArea, progress, token);
             }
 
-            if (item.Quantity > 0 && best.Count > item.Quantity)
-                best = ShrinkFiller.TrimToCount(best, item.Quantity, TrimAxis);
+            if (canonicalItem.Quantity > 0 && best.Count > canonicalItem.Quantity)
+                best = ShrinkFiller.TrimToCount(best, canonicalItem.Quantity, TrimAxis);
+
+            best = RebindAndUnCanonicalize(best, originalDrawing, sourceAngle);
 
             ReportProgress(progress, new ProgressReport
             {
@@ -108,6 +121,31 @@ namespace OpenNest
             return best;
         }
 
+        /// <summary>
+        /// Single exit point for canonical -> source frame conversion. Rebinds every Part to the
+        /// original Drawing (so consumers see the user's drawing identity, not the transient canonical copy)
+        /// and composes sourceAngle onto each Part's rotation via CanonicalFrame.FromCanonical.
+        /// </summary>
+        private static List<Part> RebindAndUnCanonicalize(List<Part> parts, Drawing original, double sourceAngle)
+        {
+            if (parts == null || parts.Count == 0)
+                return parts;
+
+            for (var i = 0; i < parts.Count; i++)
+            {
+                var p = parts[i];
+                // Rebind to `original` while preserving world pose. CreateAtOrigin rotates
+                // at the origin (keeping bbox at world (0,0)) then we offset to match p's bbox.
+                var rebound = Part.CreateAtOrigin(original, p.Rotation);
+                var delta = p.BoundingBox.Location - rebound.BoundingBox.Location;
+                rebound.Offset(delta);
+                rebound.UpdateBounds();
+                parts[i] = rebound;
+            }
+
+            return CanonicalFrame.FromCanonical(parts, sourceAngle);
+        }
+
         /// <summary>
         /// Fast path for qty 1-2: place a single part or a best-fit pair
         /// without running the full strategy pipeline.
@@ -139,6 +177,10 @@ namespace OpenNest
             var bestFits = BestFitCache.GetOrCompute(
                 drawing, Plate.Size.Length, Plate.Size.Width, Plate.PartSpacing);
 
+            // Build pair candidates with a canonical drawing so their geometry matches
+            // the coordinate frame of the cached fit results.
+            var canonicalDrawing = CanonicalFrame.AsCanonicalCopy(drawing);
+
             List<Part> bestPlacement = null;
 
             foreach (var fit in bestFits)
@@ -152,7 +194,7 @@ namespace OpenNest
                 if (fit.LongestSide > System.Math.Max(workArea.Width, workArea.Length) + Tolerance.Epsilon)
                     continue;
 
-                var landscape = fit.BuildParts(drawing);
+                var landscape = fit.BuildParts(canonicalDrawing);
                 var portrait = RotatePair90(landscape);
 
                 var lFits = TryOffsetToWorkArea(landscape, workArea);
@@ -174,6 +216,8 @@ namespace OpenNest
                     bestPlacement = candidate;
             }
 
+            // Parts are returned in canonical frame, bound to the canonical drawing.
+            // The outer Fill wrapper (Task 7) rebinds to `drawing` and composes sourceAngle onto rotation.
             return bestPlacement;
         }
 

OpenNest.Engine/Fill/Compactor.cs

@@ -1,6 +1,7 @@
 using OpenNest.Geometry;
 using System.Collections.Generic;
 using System.Linq;
+using OpenNest.Math;
 
 namespace OpenNest.Engine.Fill
 {
@@ -14,7 +15,7 @@ namespace OpenNest.Engine.Fill
         public static double Push(List<Part> movingParts, Plate plate, PushDirection direction)
         {
             var obstacleParts = plate.Parts
-                .Where(p => !movingParts.Contains(p))
+                .Where(p => !movingParts.Contains(p) && !IntersectsAny(p, movingParts))
                 .ToList();
 
             return Push(movingParts, obstacleParts, plate.WorkArea(), plate.PartSpacing, direction);
@@ -26,7 +27,7 @@ namespace OpenNest.Engine.Fill
         public static double Push(List<Part> movingParts, Plate plate, double angle)
         {
             var obstacleParts = plate.Parts
-                .Where(p => !movingParts.Contains(p))
+                .Where(p => !movingParts.Contains(p) && !IntersectsAny(p, movingParts))
                 .ToList();
 
             var direction = new Vector(System.Math.Cos(angle), System.Math.Sin(angle));
@@ -42,12 +43,16 @@ namespace OpenNest.Engine.Fill
             var opposite = -direction;
 
             var obstacleBoxes = new Box[obstacleParts.Count];
+            var obstacleSpacingBoxes = new Box[obstacleParts.Count];
             var obstacleEntities = new List<Entity>[obstacleParts.Count];
+            var halfSpacing = System.Math.Max(0, partSpacing) / 2;
 
             for (var i = 0; i < obstacleParts.Count; i++)
+            {
                 obstacleBoxes[i] = obstacleParts[i].BoundingBox;
+                obstacleSpacingBoxes[i] = SpacingBounds(obstacleBoxes[i], halfSpacing);
+            }
 
-            var halfSpacing = partSpacing / 2;
             var distance = double.MaxValue;
 
             foreach (var moving in movingParts)
@@ -73,17 +78,21 @@ namespace OpenNest.Engine.Fill
                     }
                 }
 
+                // Broad-phase bounds must enclose the spacing-offset contours.
+                // Raw bounds can miss near passes and overestimate the safe travel.
+                var movingSpacingBox = SpacingBounds(movingBox, halfSpacing);
                 for (var i = 0; i < obstacleBoxes.Length; i++)
                 {
-                    var reverseGap = SpatialQuery.DirectionalGap(movingBox, obstacleBoxes[i], opposite);
+                    var obstacleSpacingBox = obstacleSpacingBoxes[i];
+                    var reverseGap = SpatialQuery.DirectionalGap(movingSpacingBox, obstacleSpacingBox, opposite);
                     if (reverseGap > 0)
                         continue;
 
-                    var gap = SpatialQuery.DirectionalGap(movingBox, obstacleBoxes[i], direction);
+                    var gap = SpatialQuery.DirectionalGap(movingSpacingBox, obstacleSpacingBox, direction);
                     if (gap >= distance)
                         continue;
 
-                    if (!SpatialQuery.PerpendicularOverlap(movingBox, obstacleBoxes[i], direction))
+                    if (!SpatialQuery.PerpendicularOverlap(movingSpacingBox, obstacleSpacingBox, direction))
                         continue;
 
                     movingEntities ??= halfSpacing > 0
@@ -99,6 +108,13 @@ namespace OpenNest.Engine.Fill
                         : PartGeometry.GetPerimeterEntities(obstacleParts[i]);
 
                     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;
                 }
@@ -115,6 +131,37 @@ namespace OpenNest.Engine.Fill
             return 0;
         }
 
+        private static Box SpacingBounds(Box box, double spacing)
+        {
+            return new Box(box.Left - spacing, box.Bottom - spacing,
+                box.Length + 2 * spacing, box.Width + 2 * spacing);
+        }
+
+        private static bool IntersectsAny(Part candidate, List<Part> parts)
+        {
+            for (var i = 0; i < parts.Count; i++)
+            {
+                if (candidate.Intersects(parts[i], out _))
+                    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,
             Box workArea, double partSpacing, PushDirection direction)
         {
@@ -130,7 +177,7 @@ namespace OpenNest.Engine.Fill
         public static double PushBoundingBox(List<Part> movingParts, Plate plate, PushDirection direction)
         {
             var obstacleParts = plate.Parts
-                .Where(p => !movingParts.Contains(p))
+                .Where(p => !movingParts.Contains(p) && !IntersectsAny(p, movingParts))
                 .ToList();
 
             return PushBoundingBox(movingParts, obstacleParts, plate.WorkArea(), plate.PartSpacing, direction);

OpenNest.Engine/Fill/FillLinear.cs

@@ -61,92 +61,91 @@ namespace OpenNest.Engine.Fill
                 : NestDirection.Horizontal;
         }
 
-        /// <summary>
-        /// Computes the slide distance for the push algorithm, returning the
-        /// geometry-aware copy distance along the given axis.
-        /// </summary>
-        private double ComputeCopyDistance(double bboxDim, double slideDistance)
-        {
-            if (slideDistance >= double.MaxValue || slideDistance < 0)
-                return bboxDim + PartSpacing;
-
-            // The geometry-aware slide can produce a copy distance smaller than
-            // the part itself when inflated corner/arc vertices interact spuriously.
-            // Clamp to bboxDim + PartSpacing to prevent bounding box overlap.
-            return System.Math.Max(bboxDim - slideDistance, bboxDim + PartSpacing);
-        }
-
         /// <summary>
         /// Finds the geometry-aware copy distance between two identical parts along an axis.
-        /// Both parts are inflated by half-spacing for symmetric spacing.
+        /// Uses native Line/Arc entities (inflated by half-spacing) so curves are handled
+        /// exactly without polygon sampling error.
         /// </summary>
-        private double FindCopyDistance(Part partA, NestDirection direction, PartBoundary boundary)
+        private double FindCopyDistance(Part partA, NestDirection direction)
         {
             var bboxDim = GetDimension(partA.BoundingBox, direction);
             var pushDir = GetPushDirection(direction);
+            var startOffset = bboxDim + PartSpacing + Tolerance.Epsilon;
+            var offset = MakeOffset(direction, startOffset);
 
-            var locationBOffset = MakeOffset(direction, bboxDim);
+            var stationaryEntities = PartGeometry.GetOffsetPerimeterEntities(partA, HalfSpacing);
+            var movingEntities = PartGeometry.GetOffsetPerimeterEntities(
+                partA.CloneAtOffset(offset), HalfSpacing);
 
-            // Use the most efficient array-based overload to avoid all allocations.
             var slideDistance = SpatialQuery.DirectionalDistance(
-                boundary.GetEdges(pushDir), partA.Location + locationBOffset,
-                boundary.GetEdges(SpatialQuery.OppositeDirection(pushDir)), partA.Location,
-                pushDir);
+                movingEntities, stationaryEntities, pushDir);
 
-            return ComputeCopyDistance(bboxDim, slideDistance);
+            if (slideDistance >= double.MaxValue || slideDistance < 0)
+                return bboxDim + PartSpacing;
+
+            return startOffset - slideDistance;
         }
 
         /// <summary>
         /// Finds the geometry-aware copy distance between two identical patterns along an axis.
-        /// Checks every pair of parts across adjacent patterns so that multi-part
-        /// patterns (e.g. interlocking pairs) maintain spacing between ALL parts.
-        /// Both sides are inflated by half-spacing for symmetric spacing.
+        /// Checks every pair of parts across adjacent pattern copies so multi-part patterns
+        /// (e.g. interlocking pairs) maintain spacing between ALL parts. Uses native entity
+        /// geometry inflated by half-spacing — same primitive the Compactor uses — so arcs
+        /// are exact and no bbox clamp is needed.
         /// </summary>
-        private double FindPatternCopyDistance(Pattern patternA, NestDirection direction, PartBoundary[] boundaries)
+        private double FindPatternCopyDistance(Pattern patternA, NestDirection direction)
         {
-            if (patternA.Parts.Count <= 1)
-                return FindSinglePartPatternCopyDistance(patternA, direction, boundaries[0]);
+            if (patternA.Parts.Count == 1)
+                return FindCopyDistance(patternA.Parts[0], direction);
 
             var bboxDim = GetDimension(patternA.BoundingBox, direction);
             var pushDir = GetPushDirection(direction);
             var opposite = SpatialQuery.OppositeDirection(pushDir);
+            var dirVec = SpatialQuery.DirectionToOffset(pushDir, 1.0);
 
             // bboxDim already spans max(upper) - min(lower) across all parts,
             // so the start offset just needs to push beyond that plus spacing.
             var startOffset = bboxDim + PartSpacing + Tolerance.Epsilon;
             var offset = MakeOffset(direction, startOffset);
 
-            var maxCopyDistance = FindMaxPairDistance(
-                patternA.Parts, boundaries, offset, pushDir, opposite, startOffset);
+            var parts = patternA.Parts;
+            var stationaryBoxes = new Box[parts.Count];
+            var movingBoxes = new Box[parts.Count];
+            var stationaryEntities = new List<Entity>[parts.Count];
+            var movingEntities = new List<Entity>[parts.Count];
 
-            // The copy distance must be at least bboxDim + PartSpacing to prevent
-            // bounding box overlap. Cross-pair slides can underestimate when the
-            // circumscribed polygon boundary overshoots the true arc, creating
-            // spurious contacts between diagonal parts in adjacent copies.
-            return System.Math.Max(maxCopyDistance, bboxDim + PartSpacing);
-        }
+            for (var i = 0; i < parts.Count; i++)
+            {
+                stationaryBoxes[i] = parts[i].BoundingBox;
+                movingBoxes[i] = stationaryBoxes[i].Translate(offset);
+            }
 
-        /// <summary>
-        /// Tests every pair of parts across adjacent pattern copies and returns the
-        /// maximum copy distance found. Returns 0 if no valid slide was found.
-        /// </summary>
-        private static double FindMaxPairDistance(
-            List<Part> parts, PartBoundary[] boundaries, Vector offset,
-            PushDirection pushDir, PushDirection opposite, double startOffset)
-        {
             var maxCopyDistance = 0.0;
 
             for (var j = 0; j < parts.Count; j++)
             {
-                var movingEdges = boundaries[j].GetEdges(pushDir);
-                var locationB = parts[j].Location + offset;
+                var movingBox = movingBoxes[j];
 
                 for (var i = 0; i < parts.Count; i++)
                 {
+                    var stationaryBox = stationaryBoxes[i];
+
+                    // Skip if stationary is already ahead of moving in the push direction
+                    // (sliding forward would take them further apart).
+                    if (SpatialQuery.DirectionalGap(movingBox, stationaryBox, opposite) > 0)
+                        continue;
+
+                    // Skip if bboxes can't overlap along the axis perpendicular to the push.
+                    if (!SpatialQuery.PerpendicularOverlap(movingBox, stationaryBox, dirVec))
+                        continue;
+
+                    stationaryEntities[i] ??= PartGeometry.GetOffsetPerimeterEntities(
+                        parts[i], HalfSpacing);
+                    movingEntities[j] ??= PartGeometry.GetOffsetPerimeterEntities(
+                        parts[j].CloneAtOffset(offset), HalfSpacing);
+
                     var slideDistance = SpatialQuery.DirectionalDistance(
-                        movingEdges, locationB,
-                        boundaries[i].GetEdges(opposite), parts[i].Location,
-                        pushDir);
+                        movingEntities[j], stationaryEntities[i], pushDir);
 
                     if (slideDistance >= double.MaxValue || slideDistance < 0)
                         continue;
@@ -161,86 +160,15 @@ namespace OpenNest.Engine.Fill
             return maxCopyDistance;
         }
 
-        /// <summary>
-        /// Fast path for single-part patterns — no cross-part conflicts possible.
-        /// </summary>
-        private double FindSinglePartPatternCopyDistance(Pattern patternA, NestDirection direction, PartBoundary boundary)
-        {
-            var template = patternA.Parts[0];
-            return FindCopyDistance(template, direction, boundary);
-        }
-
-        /// <summary>
-        /// Gets offset boundary lines for all parts in a pattern using a shared boundary.
-        /// </summary>
-        private static List<Line> GetPatternLines(Pattern pattern, PartBoundary boundary, PushDirection direction)
-        {
-            var lines = new List<Line>();
-
-            foreach (var part in pattern.Parts)
-                lines.AddRange(boundary.GetLines(part.Location, direction));
-
-            return lines;
-        }
-
-        /// <summary>
-        /// Gets boundary lines for all parts in a pattern, with an additional
-        /// location offset applied. Avoids cloning the pattern.
-        /// </summary>
-        private static List<Line> GetOffsetPatternLines(Pattern pattern, Vector offset, PartBoundary boundary, PushDirection direction)
-        {
-            var lines = new List<Line>();
-
-            foreach (var part in pattern.Parts)
-                lines.AddRange(boundary.GetLines(part.Location + offset, direction));
-
-            return lines;
-        }
-
-        /// <summary>
-        /// Creates boundaries for all parts in a pattern. Parts that share the same
-        /// program geometry (same drawing and rotation) reuse the same boundary instance.
-        /// </summary>
-        private PartBoundary[] CreateBoundaries(Pattern pattern)
-        {
-            var boundaries = new PartBoundary[pattern.Parts.Count];
-            var cache = new List<(Drawing drawing, double rotation, PartBoundary boundary)>();
-
-            for (var i = 0; i < pattern.Parts.Count; i++)
-            {
-                var part = pattern.Parts[i];
-                PartBoundary found = null;
-
-                foreach (var entry in cache)
-                {
-                    if (entry.drawing == part.BaseDrawing && entry.rotation.IsEqualTo(part.Rotation))
-                    {
-                        found = entry.boundary;
-                        break;
-                    }
-                }
-
-                if (found == null)
-                {
-                    found = new PartBoundary(part, HalfSpacing);
-                    cache.Add((part.BaseDrawing, part.Rotation, found));
-                }
-
-                boundaries[i] = found;
-            }
-
-            return boundaries;
-        }
-
         /// <summary>
         /// Tiles a pattern along the given axis, returning the cloned parts
         /// (does not include the original pattern's parts). For multi-part
         /// patterns, also adds individual parts from the next incomplete copy
         /// that still fit within the work area.
         /// </summary>
-        private List<Part> TilePattern(Pattern basePattern, NestDirection direction, PartBoundary[] boundaries)
+        private List<Part> TilePattern(Pattern basePattern, NestDirection direction)
         {
-            var copyDistance = FindPatternCopyDistance(basePattern, direction, boundaries);
+            var copyDistance = FindPatternCopyDistance(basePattern, direction);
 
             if (copyDistance <= 0)
                 return new List<Part>();
@@ -394,11 +322,10 @@ namespace OpenNest.Engine.Fill
         private List<Part> FillGrid(Pattern pattern, NestDirection direction)
         {
             var perpAxis = PerpendicularAxis(direction);
-            var boundaries = CreateBoundaries(pattern);
 
             // Step 1: Tile along primary axis
             var row = new List<Part>(pattern.Parts);
-            row.AddRange(TilePattern(pattern, direction, boundaries));
+            row.AddRange(TilePattern(pattern, direction));
 
             if (pattern.Parts.Count > 1 && HasOverlappingParts(row, out var a1, out var b1))
             {
@@ -410,7 +337,7 @@ namespace OpenNest.Engine.Fill
             // If primary tiling didn't produce copies, just tile along perpendicular
             if (row.Count <= pattern.Parts.Count)
             {
-                row.AddRange(TilePattern(pattern, perpAxis, boundaries));
+                row.AddRange(TilePattern(pattern, perpAxis));
 
                 if (pattern.Parts.Count > 1 && HasOverlappingParts(row, out var a2, out var b2))
                 {
@@ -427,9 +354,8 @@ namespace OpenNest.Engine.Fill
             rowPattern.Parts.AddRange(row);
             rowPattern.UpdateBounds();
 
-            var rowBoundaries = CreateBoundaries(rowPattern);
             var gridResult = new List<Part>(rowPattern.Parts);
-            gridResult.AddRange(TilePattern(rowPattern, perpAxis, rowBoundaries));
+            gridResult.AddRange(TilePattern(rowPattern, perpAxis));
 
             if (HasOverlappingParts(gridResult, out var a3, out var b3))
             {
@@ -481,9 +407,8 @@ namespace OpenNest.Engine.Fill
                 return seed;
 
             var template = seed.Parts[0];
-            var boundary = new PartBoundary(template, HalfSpacing);
 
-            var copyDistance = FindCopyDistance(template, direction, boundary);
+            var copyDistance = FindCopyDistance(template, direction);
 
             if (copyDistance <= 0)
                 return seed;

OpenNest.Engine/Fill/IterativeShrinkFiller.cs

@@ -1,6 +1,7 @@
 using OpenNest.Geometry;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -130,17 +131,13 @@ namespace OpenNest.Engine.Fill
 
             var placed = filler.FillItems(workItems, shrinkWrapper, token);
 
-            // Build leftovers: compare placed count to original quantities.
-            // RemnantFiller.FillItems does NOT mutate NestItem.Quantity.
+            // Build leftovers: compare placed count to original quantities by drawing
+            // reference. RemnantFiller.FillItems does NOT mutate NestItem.Quantity.
             var leftovers = new List<NestItem>();
             foreach (var item in items)
             {
-                var placedCount = 0;
-                foreach (var p in placed)
-                {
-                    if (p.BaseDrawing.Name == item.Drawing.Name)
-                        placedCount++;
-                }
+                var placedCount = placed.Count(p =>
+                    ReferenceEquals(p.BaseDrawing, item.Drawing));
 
                 if (item.Quantity <= 0)
                     continue; // unlimited items are always "satisfied" — no leftover

OpenNest.Engine/Fill/RemnantFiller.cs

@@ -58,20 +58,20 @@ namespace OpenNest.Engine.Fill
             return allParts;
         }
 
-        private static Dictionary<string, int> BuildLocalQuantities(List<NestItem> items)
+        private static Dictionary<Drawing, int> BuildLocalQuantities(List<NestItem> items)
         {
-            var localQty = new Dictionary<string, int>(items.Count);
+            var localQty = new Dictionary<Drawing, int>(items.Count, ReferenceEqualityComparer.Instance);
             foreach (var item in items)
-                localQty[item.Drawing.Name] = item.Quantity;
+                localQty[item.Drawing] = item.Quantity;
             return localQty;
         }
 
-        private static double FindMinItemDimension(List<NestItem> items, Dictionary<string, int> localQty)
+        private static double FindMinItemDimension(List<NestItem> items, Dictionary<Drawing, int> localQty)
         {
             var minDim = double.MaxValue;
             foreach (var item in items)
             {
-                if (localQty[item.Drawing.Name] <= 0)
+                if (localQty[item.Drawing] <= 0)
                     continue;
                 var bb = item.Drawing.Program.BoundingBox();
                 var dim = System.Math.Min(bb.Width, bb.Length);
@@ -84,7 +84,7 @@ namespace OpenNest.Engine.Fill
         private bool TryFillOneItem(
             List<NestItem> items,
             List<Box> freeBoxes,
-            Dictionary<string, int> localQty,
+            Dictionary<Drawing, int> localQty,
             Func<NestItem, Box, List<Part>> fillFunc,
             List<Part> allParts,
             CancellationToken token)
@@ -94,7 +94,7 @@ namespace OpenNest.Engine.Fill
                 if (token.IsCancellationRequested)
                     return false;
 
-                var qty = localQty[item.Drawing.Name];
+                var qty = localQty[item.Drawing];
                 if (qty <= 0)
                     continue;
 
@@ -110,7 +110,7 @@ namespace OpenNest.Engine.Fill
                     RemoveTopmostPart(placed);
 
                 allParts.AddRange(placed);
-                localQty[item.Drawing.Name] = System.Math.Max(0, qty - placed.Count);
+                localQty[item.Drawing] = System.Math.Max(0, qty - placed.Count);
 
                 // Add the envelope of all placed parts as a single obstacle
                 // rather than individual bounding boxes, preventing the

OpenNest.Engine/Jobs/Adapters/DrawingJobMapper.cs

@@ -0,0 +1,77 @@
+using System;
+using OpenNest.CNC;
+
+namespace OpenNest;
+
+/// <summary>Explicit-ID input mapping and exact supported-geometry reconstruction. Never retains caller objects.</summary>
+public static class DrawingJobMapper
+{
+    public static NestJobPart FromDrawing(string partId, Drawing drawing, int quantity)
+    {
+        ArgumentNullException.ThrowIfNull(drawing);
+        var constraints = drawing.Constraints;
+        return new NestJobPart(partId, PartGeometrySnapshot.FromProgram(drawing.Program), quantity, drawing.Priority,
+            constraints == null ? RotationPolicy.Automatic :
+                RotationPolicy.FromLegacy(constraints.StepAngle, constraints.StartAngle, constraints.EndAngle));
+    }
+
+    public static NestJobPart FromItem(string partId, NestItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        ArgumentNullException.ThrowIfNull(item.Drawing);
+        return new NestJobPart(partId, PartGeometrySnapshot.FromProgram(item.Drawing.Program), item.Quantity,
+            item.Priority, RotationPolicy.FromLegacy(item.StepAngle, item.RotationStart, item.RotationEnd));
+    }
+
+    /// <summary>Available stock is explicit; the legacy plate repeat count is not inventory.</summary>
+    public static NestPlateStock FromPlate(string stockId, Plate plate, int? quantity)
+    {
+        ArgumentNullException.ThrowIfNull(plate);
+        return new NestPlateStock(stockId, plate.Size, quantity, plate.PartSpacing, plate.EdgeSpacing, plate.Quadrant);
+    }
+
+    public static Program ToProgram(PartGeometrySnapshot geometry)
+    {
+        ArgumentNullException.ThrowIfNull(geometry);
+        var program = new Program(geometry.Mode);
+        foreach (var motion in geometry.Motions)
+        {
+            var code = motion.Type switch
+            {
+                CodeType.RapidMove => (Motion)new RapidMove(motion.X, motion.Y),
+                CodeType.LinearMove => new LinearMove(motion.X, motion.Y) { Layer = motion.Layer },
+                CodeType.ArcMove => new ArcMove(motion.X, motion.Y, motion.CenterX, motion.CenterY, motion.Rotation)
+                    { Layer = motion.Layer },
+                _ => throw new NotSupportedException("Unsupported snapshot motion.")
+            };
+            code.Suppressed = motion.Suppressed;
+            program.Codes.Add(code);
+        }
+        return program;
+    }
+
+    internal static Drawing CreateDrawing(NestJobPart part)
+    {
+        var drawing = new Drawing(part.Id, ToProgram(part.Geometry)) { Priority = part.Priority };
+        drawing.Quantity.Required = part.Quantity;
+        drawing.Constraints = new NestConstraints
+        {
+            StepAngle = LegacyStep(part.Rotation),
+            StartAngle = part.Rotation.Start,
+            EndAngle = part.Rotation.End
+        };
+        return drawing;
+    }
+
+    // A fixed angle needs a nonzero legacy step so it is not misread as automatic.
+    internal static double LegacyStep(RotationPolicy policy) => policy.Kind == RotationPolicyKind.Fixed
+        ? OpenNest.Math.Angle.TwoPI : policy.Step;
+
+    internal static Plate CreatePlate(NestPlateStock stock) => new(stock.Size)
+    {
+        Quantity = 1,
+        PartSpacing = stock.PartSpacing,
+        EdgeSpacing = stock.EdgeSpacing,
+        Quadrant = stock.Quadrant
+    };
+}

OpenNest.Engine/Jobs/Adapters/LegacyPlateNesterAdapter.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>
+/// A fresh private legacy plate/drawing/item graph for each call. Only returned poses cross the boundary;
+/// legacy quantity mutations are deliberately ignored. Does not certify geometric safety or rotation compliance.
+/// </summary>
+public sealed class LegacyPlateNesterAdapter : IPlateNester
+{
+    private readonly Func<Plate, NestEngineBase> engineFactory;
+
+    public LegacyPlateNesterAdapter(Func<Plate, NestEngineBase> engineFactory)
+    {
+        ArgumentNullException.ThrowIfNull(engineFactory);
+        this.engineFactory = engineFactory;
+    }
+
+    /// <summary>Convenience overload delegating to <see cref="PlateNesterFactory"/> so strategy
+    /// resolution has a single source of truth; rejects unknown keys. Never reads or changes the
+    /// process-global NestEngineRegistry.</summary>
+    public static IPlateNester Create(string strategy) => PlateNesterFactory.Create(strategy);
+
+    public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        token.ThrowIfCancellationRequested();
+        var plate = DrawingJobMapper.CreatePlate(request.Stock);
+        var items = new List<NestItem>();
+        var identities = new Dictionary<Drawing, string>(ReferenceEqualityComparer.Instance);
+        foreach (var requirement in request.Parts)
+        {
+            var drawing = DrawingJobMapper.CreateDrawing(requirement);
+            identities.Add(drawing, requirement.Id);
+            items.Add(new NestItem
+            {
+                Drawing = drawing,
+                Quantity = requirement.Quantity,
+                Priority = requirement.Priority,
+                StepAngle = DrawingJobMapper.LegacyStep(requirement.Rotation),
+                RotationStart = requirement.Rotation.Start,
+                RotationEnd = requirement.Rotation.End
+            });
+        }
+        var engine = engineFactory(plate) ?? throw new InvalidOperationException("Legacy engine factory returned null.");
+        var legacyProgress = progress == null ? null : new LegacyProgress(progress, request.Stock.Id);
+        var parts = engine.Nest(items, legacyProgress, token);
+        token.ThrowIfCancellationRequested();
+        if (parts == null) throw new InvalidOperationException("Legacy engine returned null placements.");
+        var placements = new List<NestJobPlacement>();
+        foreach (var part in parts)
+        {
+            if (part?.BaseDrawing == null || !identities.TryGetValue(part.BaseDrawing, out var id))
+                throw new InvalidOperationException("Legacy placement does not reference a private requirement drawing.");
+            placements.Add(new NestJobPlacement(id, 0, part.Location.X, part.Location.Y, part.Rotation));
+        }
+        return new PlateCandidate(placements);
+    }
+
+    private sealed class LegacyProgress(IProgress<NestJobProgress> progress, string stockId) : IProgress<NestProgress>
+    {
+        public void Report(NestProgress value)
+        {
+            ArgumentNullException.ThrowIfNull(value);
+            progress.Report(new NestJobProgress(NestJobStage.EvaluatingCandidate, stockId, -1, 0, 0, value));
+        }
+    }
+}

OpenNest.Engine/Jobs/Adapters/NestResultMaterializer.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+/// <summary>A detached mutable domain nest plus explicit requirement identity (never inferred from names).</summary>
+public sealed class MaterializedNestResult
+{
+    internal MaterializedNestResult(Nest nest, Dictionary<string, Drawing> drawings)
+    {
+        Nest = nest;
+        DrawingsByPartId = new ReadOnlyDictionary<string, Drawing>(drawings);
+    }
+
+    public Nest Nest { get; }
+    public IReadOnlyDictionary<string, Drawing> DrawingsByPartId { get; }
+}
+
+/// <summary>Materializes a result from the same job. Geometry safety remains the solver's future validation boundary.</summary>
+public static class NestResultMaterializer
+{
+    public static MaterializedNestResult Materialize(NestJob job, NestJobResult result)
+    {
+        ArgumentNullException.ThrowIfNull(job);
+        ArgumentNullException.ThrowIfNull(result);
+        var nest = new Nest();
+        var drawings = job.Parts.ToDictionary(p => p.Id, DrawingJobMapper.CreateDrawing, StringComparer.Ordinal);
+        foreach (var drawing in drawings.Values) nest.Drawings.Add(drawing);
+        foreach (var sheet in result.Plates)
+        {
+            var plate = DrawingJobMapper.CreatePlate(sheet.Stock);
+            foreach (var pose in sheet.Placements)
+            {
+                if (!drawings.TryGetValue(pose.PartId, out var drawing))
+                    throw new ArgumentException("Result contains a requirement not present in the job.", nameof(result));
+                // Do not use CreateAtOrigin: it normalizes bounds and would change the snapshot frame.
+                var part = new Part(drawing);
+                part.Rotate(pose.Rotation);
+                part.Location = new Vector(pose.X, pose.Y);
+                part.UpdateBounds();
+                // Quantity=1 is set before the only attachment; Plate's event owns Nested accounting.
+                plate.Parts.Add(part);
+            }
+            nest.Plates.Add(plate);
+        }
+        return new MaterializedNestResult(nest, drawings);
+    }
+}

OpenNest.Engine/Jobs/CandidateProgressBridge.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace OpenNest;
+
+/// <summary>
+/// Bridges legacy <see cref="IProgress{NestProgress}"/> reporting into job progress while a candidate
+/// trial is being evaluated. Used by both the legacy adapter and the migrated built-in nesters so the
+/// stage/context mapping has one implementation.
+/// </summary>
+internal static class CandidateProgressBridge
+{
+    internal static IProgress<NestProgress> Create(IProgress<NestJobProgress> progress, string stockId)
+    {
+        if (progress == null) return null;
+        return new LegacyToJob(progress, stockId);
+    }
+
+    private sealed class LegacyToJob(IProgress<NestJobProgress> progress, string stockId) : IProgress<NestProgress>
+    {
+        public void Report(NestProgress value)
+        {
+            ArgumentNullException.ThrowIfNull(value);
+            progress.Report(new NestJobProgress(NestJobStage.EvaluatingCandidate, stockId, -1, 0, 0, value));
+        }
+    }
+}

OpenNest.Engine/Jobs/INestingEngine.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>Synchronous whole-job solver. Cancellation throws, rather than returning partial success.</summary>
+public interface INestingEngine
+{
+    NestJobResult Solve(NestJob job, IProgress<NestJobProgress> progress = null, CancellationToken token = default);
+}

OpenNest.Engine/Jobs/IPlateNester.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>Places on one sheet only. Must not change stock, demand, or caller-owned domain objects.</summary>
+public interface IPlateNester
+{
+    PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default);
+}

OpenNest.Engine/Jobs/NestJob.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest;
+
+/// <summary>One material/unit system's requirements. Collections are copied; all nested values are immutable.</summary>
+public sealed class NestJob
+{
+    public NestJob(IEnumerable<NestJobPart> parts, IEnumerable<NestPlateStock> plates, NestJobOptions options = null)
+    {
+        Parts = Own(parts);
+        Plates = Own(plates);
+        Options = options ?? new NestJobOptions();
+        if (Parts.Select(p => p.Id).Distinct(StringComparer.Ordinal).Count() != Parts.Count ||
+            Plates.Select(p => p.Id).Distinct(StringComparer.Ordinal).Count() != Plates.Count)
+            throw new ArgumentException("Part and stock IDs must each be unique.");
+    }
+
+    public IReadOnlyList<NestJobPart> Parts { get; }
+    public IReadOnlyList<NestPlateStock> Plates { get; }
+    public NestJobOptions Options { get; }
+
+    internal static IReadOnlyList<T> Own<T>(IEnumerable<T> source)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        var values = source.ToArray();
+        if (values.Any(value => value is null))
+            throw new ArgumentException("Null entries are not allowed.", nameof(source));
+        return Array.AsReadOnly(values);
+    }
+}

OpenNest.Engine/Jobs/NestJobCandidateComparer.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest;
+
+/// <summary>Ranks independent plate trials: priority fulfillment, sheet area, placement envelope, then input order.</summary>
+public sealed class NestJobCandidateComparer
+{
+    private readonly IReadOnlyList<NestJobPart> parts;
+
+    public NestJobCandidateComparer(IReadOnlyList<NestJobPart> parts)
+    {
+        this.parts = parts ?? throw new ArgumentNullException(nameof(parts));
+    }
+
+    /// <summary>Returns positive when the left trial is preferred.</summary>
+    public int Compare(PlateCandidate left, NestPlateStock leftStock, int leftIndex,
+        PlateCandidate right, NestPlateStock rightStock, int rightIndex)
+    {
+        var priorities = parts.Select(part => part.Priority).Distinct().OrderBy(priority => priority);
+        foreach (var priority in priorities)
+        {
+            var leftCount = Count(left, priority);
+            var rightCount = Count(right, priority);
+            if (leftCount != rightCount) return leftCount.CompareTo(rightCount);
+        }
+
+        var area = Area(rightStock).CompareTo(Area(leftStock));
+        if (area != 0) return area;
+
+        var envelope = Envelope(right).CompareTo(Envelope(left));
+        if (envelope != 0) return envelope;
+
+        return rightIndex.CompareTo(leftIndex);
+    }
+
+    private int Count(PlateCandidate candidate, int priority) => candidate.Placements.Count(placement =>
+        parts.First(part => part.Id == placement.PartId).Priority == priority);
+
+    private static double Area(NestPlateStock stock) => stock.Size.Width * stock.Size.Length;
+
+    private static double Envelope(PlateCandidate candidate)
+    {
+        if (candidate.Placements.Count == 0) return 0;
+        var xs = candidate.Placements.Select(placement => placement.X);
+        var ys = candidate.Placements.Select(placement => placement.Y);
+        return (xs.Max() - xs.Min()) * (ys.Max() - ys.Min());
+    }
+}

OpenNest.Engine/Jobs/NestJobOptions.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace OpenNest;
+
+/// <summary>Immutable per-job options; selection never changes the legacy global registry.</summary>
+public sealed class NestJobOptions
+{
+    public NestJobOptions(string placementStrategy = "Default", int? maxPlates = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(placementStrategy);
+        if (maxPlates <= 0) throw new ArgumentOutOfRangeException(nameof(maxPlates));
+        PlacementStrategy = placementStrategy;
+        MaxPlates = maxPlates;
+    }
+
+    public string PlacementStrategy { get; }
+    /// <summary>Maximum physical sheets to commit, or null for no explicit cap.</summary>
+    public int? MaxPlates { get; }
+}

OpenNest.Engine/Jobs/NestJobPart.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace OpenNest;
+
+/// <summary>An immutable requirement, independent of drawing names, UI state, and drawing quantity counters.</summary>
+public sealed class NestJobPart
+{
+    public NestJobPart(string id, PartGeometrySnapshot geometry, int quantity, int priority = 0,
+        RotationPolicy rotation = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(id);
+        ArgumentNullException.ThrowIfNull(geometry);
+        if (quantity <= 0) throw new ArgumentOutOfRangeException(nameof(quantity));
+        Id = id;
+        Geometry = geometry;
+        Quantity = quantity;
+        Priority = priority;
+        Rotation = rotation ?? RotationPolicy.Automatic;
+    }
+
+    public string Id { get; }
+    public PartGeometrySnapshot Geometry { get; }
+    /// <summary>Positive number requested; never decremented by placement code.</summary>
+    public int Quantity { get; }
+    public int Priority { get; }
+    public RotationPolicy Rotation { get; }
+}

OpenNest.Engine/Jobs/NestJobPlacementValidator.cs

@@ -0,0 +1,307 @@
+using System;
+using System.Collections.Generic;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest;
+
+/// <summary>Validates a trial against immutable job geometry before the runner commits accounting.</summary>
+internal static class NestJobPlacementValidator
+{
+    private const double Epsilon = 0.0000001;
+
+    internal static void ValidateCandidate(PlateCandidate candidate, NestPlateStock stock,
+        IReadOnlyDictionary<string, int> remaining, IReadOnlyDictionary<string, NestJobPart> parts)
+    {
+        if (candidate == null) throw new InvalidOperationException("The plate nester returned a null candidate.");
+        var counts = new Dictionary<string, int>(StringComparer.Ordinal);
+        var placed = new List<ShapeTopology>();
+        foreach (var placement in candidate.Placements)
+        {
+            if (placement.PartId == null || !remaining.TryGetValue(placement.PartId, out var available) ||
+                !parts.TryGetValue(placement.PartId, out var part))
+                throw new InvalidOperationException("Candidate references an unknown requirement ID.");
+            if (!double.IsFinite(placement.X) || !double.IsFinite(placement.Y) || !double.IsFinite(placement.Rotation))
+                throw new InvalidOperationException("Candidate poses must be finite.");
+            counts.TryGetValue(placement.PartId, out var count);
+            if (count >= available) throw new InvalidOperationException("Candidate overproduces a requirement.");
+            if (!RotationIsAllowed(part.Rotation, placement.Rotation))
+                throw new InvalidOperationException("Candidate rotation is not allowed for the requirement.");
+
+            var shape = Transform(CreateShape(part.Geometry), placement);
+            if (!FitsWorkArea(shape, stock))
+                throw new InvalidOperationException("Candidate placement falls outside the usable stock area.");
+            foreach (var other in placed)
+            {
+                if (Overlaps(shape, other))
+                    throw new InvalidOperationException("Candidate placements overlap.");
+                if (stock.PartSpacing > 0 && Distance(shape, other) < stock.PartSpacing - Epsilon)
+                    throw new InvalidOperationException("Candidate placements violate required part spacing.");
+            }
+
+            placed.Add(shape);
+            counts[placement.PartId] = count + 1;
+        }
+    }
+
+    internal static void ValidateGeometry(PartGeometrySnapshot geometry)
+    {
+        _ = CreateShape(geometry);
+    }
+
+    private static bool RotationIsAllowed(RotationPolicy policy, double rotation)
+    {
+        if (policy.Kind == RotationPolicyKind.Automatic) return true;
+        if (policy.Kind == RotationPolicyKind.Fixed)
+            return AnglesEqual(rotation, policy.Start);
+        if (rotation < policy.Start - Epsilon || rotation > policy.End + Epsilon) return false;
+        var steps = (rotation - policy.Start) / policy.Step;
+        return System.Math.Abs(steps - System.Math.Round(steps)) <= Epsilon;
+    }
+
+    private static bool AnglesEqual(double left, double right)
+    {
+        var delta = (left - right) % (System.Math.PI * 2);
+        return System.Math.Abs(delta) <= Epsilon || System.Math.Abs(System.Math.Abs(delta) - System.Math.PI * 2) <= Epsilon;
+    }
+
+    private static ShapeTopology CreateShape(PartGeometrySnapshot geometry)
+    {
+        var entities = ConvertProgram.ToGeometry(DrawingJobMapper.ToProgram(geometry));
+        var cutEntities = new List<Entity>();
+        foreach (var entity in entities)
+            if (!ReferenceEquals(entity.Layer, SpecialLayers.Rapid))
+                cutEntities.Add(entity);
+
+        var contours = ShapeBuilder.GetShapes(cutEntities);
+        if (contours.Count == 0) throw new ArgumentException("Geometry must contain a closed contour.");
+        foreach (var contour in contours)
+            ValidateContour(contour);
+
+        var profile = new ShapeProfile(cutEntities);
+        profile.NormalizeWinding();
+        return new ShapeTopology(profile.Perimeter, profile.Cutouts);
+    }
+
+    private static void ValidateContour(Shape contour)
+    {
+        if (!contour.IsClosed())
+            throw new ArgumentException("Geometry must contain closed contours with usable edges.");
+        foreach (var entity in contour.Entities)
+            if (entity.Length <= Epsilon)
+                throw new ArgumentException("Geometry contains a zero-length edge.");
+        if (contour.Area() <= Epsilon)
+            throw new ArgumentException("Geometry must contain non-degenerate contours.");
+    }
+
+    private static ShapeTopology Transform(ShapeTopology source, NestJobPlacement placement)
+    {
+        var perimeter = TransformContour(source.Perimeter, placement);
+        var cutouts = new List<Shape>(source.Cutouts.Count);
+        foreach (var cutout in source.Cutouts)
+            cutouts.Add(TransformContour(cutout, placement));
+        return new ShapeTopology(perimeter, cutouts);
+    }
+
+    private static Shape TransformContour(Shape source, NestJobPlacement placement)
+    {
+        var contour = (Shape)source.Clone();
+        contour.Rotate(placement.Rotation);
+        contour.Offset(placement.X, placement.Y);
+        return contour;
+    }
+
+    private static bool FitsWorkArea(ShapeTopology shape, NestPlateStock stock)
+    {
+        var workArea = WorkArea(stock);
+        if (!FitsWorkArea(shape.Perimeter, workArea)) return false;
+        foreach (var cutout in shape.Cutouts)
+            if (!FitsWorkArea(cutout, workArea)) return false;
+        return true;
+    }
+
+    private static Box WorkArea(NestPlateStock stock)
+    {
+        var left = stock.Quadrant is 1 or 4 ? 0 : -stock.Size.Length;
+        var bottom = stock.Quadrant is 1 or 2 ? 0 : -stock.Size.Width;
+        return new Box(left + stock.EdgeSpacing.Left, bottom + stock.EdgeSpacing.Bottom,
+            stock.Size.Length - stock.EdgeSpacing.Left - stock.EdgeSpacing.Right,
+            stock.Size.Width - stock.EdgeSpacing.Bottom - stock.EdgeSpacing.Top);
+    }
+
+    private static bool FitsWorkArea(Shape contour, Box workArea)
+    {
+        var bounds = contour.BoundingBox;
+        return bounds.Left >= workArea.Left - Epsilon && bounds.Right <= workArea.Right + Epsilon &&
+            bounds.Bottom >= workArea.Bottom - Epsilon && bounds.Top <= workArea.Top + Epsilon;
+    }
+
+    private static bool Overlaps(ShapeTopology left, ShapeTopology right)
+    {
+        var leftPoly = ToPolygon(left.Perimeter);
+        var rightPoly = ToPolygon(right.Perimeter);
+        if (!leftPoly.BoundingBox.Intersects(rightPoly.BoundingBox))
+            return false;
+        // True material overlap requires shared interior area, not boundary touching.
+        // Edge/corner contact (zero clearance) is a valid placement when part spacing is zero.
+        return InteriorOverlap(leftPoly, left, rightPoly, right);
+    }
+
+    private static bool InteriorOverlap(Polygon leftPoly, ShapeTopology left, Polygon rightPoly, ShapeTopology right)
+    {
+        // The intersection of two polygons is either empty, a region of positive area (true overlap),
+        // or a zero-area line/point (boundary contact). Test the interior of the intersection region:
+        // a point strictly inside BOTH perimeters and outside both parts' holes proves shared material.
+        foreach (var point in InteriorWitnessPoints(leftPoly, rightPoly))
+        {
+            if (StrictlyInside(leftPoly, point) && !InAnyHole(left, point) &&
+                StrictlyInside(rightPoly, point) && !InAnyHole(right, point))
+                return true;
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Points that lie in the interior of the perimeter-perimeter intersection when one exists.
+    /// For each pair of crossing edges, the two interior-side vertices (one from each polygon)
+    /// have their midpoint inside both perimeters; that midpoint is a witness of positive-area
+    /// overlap. For containment, an interior vertex of the inner perimeter witnesses it.
+    /// </summary>
+    private static IEnumerable<Vector> InteriorWitnessPoints(Polygon left, Polygon right)
+    {
+        foreach (var l in left.ToLines())
+            foreach (var r in right.ToLines())
+                if (l.Intersects(r, out var pt) && pt.IsValid())
+                {
+                    yield return Midpoint(l, pt);
+                    yield return Midpoint(r, pt);
+                }
+        // Containment: an interior point of one polygon inside the other. Use a point pulled
+        // toward the centroid of each polygon from a vertex (guaranteed interior for simple shapes).
+        foreach (var poly in new[] { left, right })
+        {
+            foreach (var vertex in poly.Vertices)
+            {
+                var centroid = Centroid(poly);
+                yield return (vertex + centroid) * 0.5;
+            }
+        }
+    }
+
+    private static Vector Midpoint(Line line, Vector point)
+    {
+        var other = line.StartPoint.DistanceTo(point) <= line.EndPoint.DistanceTo(point)
+            ? line.EndPoint
+            : line.StartPoint;
+        return (other + point) * 0.5;
+    }
+
+    private static Vector Centroid(Polygon polygon)
+    {
+        var n = polygon.IsClosed() ? polygon.Vertices.Count - 1 : polygon.Vertices.Count;
+        var sum = Vector.Zero;
+        for (var i = 0; i < n; i++)
+            sum += polygon.Vertices[i];
+        return sum / n;
+    }
+
+    /// <summary>
+    /// Winding-number point-in-polygon. Returns false for points on an edge or vertex.
+    /// </summary>
+    private static bool StrictlyInside(Polygon polygon, Vector point)
+    {
+        var n = polygon.IsClosed() ? polygon.Vertices.Count - 1 : polygon.Vertices.Count;
+        if (n < 3) return false;
+        var winding = 0;
+        for (var i = 0; i < n; i++)
+        {
+            var p1 = polygon.Vertices[i];
+            var p2 = polygon.Vertices[(i + 1) % n];
+            if (OnSegment(p1, p2, point)) return false;
+            if (p1.Y <= point.Y)
+            {
+                if (p2.Y > point.Y && IsLeft(p1, p2, point) > 0)
+                    winding++;
+            }
+            else if (p2.Y <= point.Y && IsLeft(p1, p2, point) < 0)
+            {
+                winding--;
+            }
+        }
+        return winding != 0;
+    }
+
+    private static bool OnSegment(Vector a, Vector b, Vector p)
+    {
+        var cross = (b.X - a.X) * (p.Y - a.Y) - (b.Y - a.Y) * (p.X - a.X);
+        if (!cross.IsEqualTo(0.0)) return false;
+        return System.Math.Min(a.X, b.X) - Epsilon <= p.X && p.X <= System.Math.Max(a.X, b.X) + Epsilon &&
+               System.Math.Min(a.Y, b.Y) - Epsilon <= p.Y && p.Y <= System.Math.Max(a.Y, b.Y) + Epsilon;
+    }
+
+    private static double IsLeft(Vector p1, Vector p2, Vector p) =>
+        (p2.X - p1.X) * (p.Y - p1.Y) - (p2.Y - p1.Y) * (p.X - p1.X);
+
+    private static bool InAnyHole(ShapeTopology topology, Vector point)
+    {
+        foreach (var cutout in topology.Cutouts)
+            if (ToPolygon(cutout).ContainsPoint(point))
+                return true;
+        return false;
+    }
+
+    private static double Distance(ShapeTopology left, ShapeTopology right)
+    {
+        var result = double.PositiveInfinity;
+        foreach (var leftContour in AllContours(left))
+            foreach (var rightContour in AllContours(right))
+                result = System.Math.Min(result, BoundaryDistance(ToPolygon(leftContour), ToPolygon(rightContour)));
+        return result;
+    }
+
+    private static IEnumerable<Shape> AllContours(ShapeTopology shape)
+    {
+        yield return shape.Perimeter;
+        foreach (var cutout in shape.Cutouts)
+            yield return cutout;
+    }
+
+    private static List<Polygon> ToPolygons(List<Shape> contours)
+    {
+        var polygons = new List<Polygon>(contours.Count);
+        foreach (var contour in contours)
+            polygons.Add(ToPolygon(contour));
+        return polygons;
+    }
+
+    private static Polygon ToPolygon(Shape contour)
+    {
+        var polygon = contour.ToPolygon();
+        polygon.UpdateBounds();
+        return polygon;
+    }
+
+    private static double BoundaryDistance(Polygon left, Polygon right)
+    {
+        var result = double.PositiveInfinity;
+        foreach (var leftLine in left.ToLines())
+        {
+            foreach (var rightLine in right.ToLines())
+            {
+                if (leftLine.Intersects(rightLine)) return 0;
+                result = System.Math.Min(result, leftLine.ClosestPointTo(rightLine.StartPoint).DistanceTo(rightLine.StartPoint));
+                result = System.Math.Min(result, leftLine.ClosestPointTo(rightLine.EndPoint).DistanceTo(rightLine.EndPoint));
+                result = System.Math.Min(result, rightLine.ClosestPointTo(leftLine.StartPoint).DistanceTo(leftLine.StartPoint));
+                result = System.Math.Min(result, rightLine.ClosestPointTo(leftLine.EndPoint).DistanceTo(leftLine.EndPoint));
+            }
+        }
+        return result;
+    }
+
+    private sealed class ShapeTopology(Shape perimeter, List<Shape> cutouts)
+    {
+        internal Shape Perimeter { get; } = perimeter;
+        internal List<Shape> Cutouts { get; } = cutouts;
+    }
+}

OpenNest.Engine/Jobs/NestJobProgress.cs

@@ -0,0 +1,10 @@
+namespace OpenNest;
+
+public enum NestJobStage { EvaluatingCandidate, PlateCommitted }
+
+/// <summary>
+/// Whole-job progress. Counts change only after a physical sheet commits; LegacyProgress is optional
+/// non-authoritative detail from a plate nester while its candidate remains under evaluation.
+/// </summary>
+public sealed record NestJobProgress(NestJobStage Stage, string StockId, int PlateIndex,
+    int CommittedPlates, int CommittedParts, NestProgress LegacyProgress = null);

OpenNest.Engine/Jobs/NestJobResult.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+
+namespace OpenNest;
+
+public enum NestJobStatus { Complete, Incomplete }
+public enum NestJobStopReason { Completed, StockExhausted, NoPlacementFound, PlateLimitReached }
+
+/// <summary>
+/// Rotate about the snapshot origin, then translate by X/Y into the selected plate quadrant frame.
+/// Rotation is in radians. InstanceIndex is zero-based and unique within a part requirement across the job.
+/// The runner assigns final instance indices when committing a candidate.
+/// </summary>
+public sealed record NestJobPlacement(string PartId, int InstanceIndex, double X, double Y, double Rotation);
+
+/// <summary>Requested = Placed + Unplaced for a requirement ID.</summary>
+public sealed record PartFulfillment(string PartId, int Requested, int Placed, int Unplaced);
+
+/// <summary>Used counts physical sheets; Remaining is null only for unlimited stock.</summary>
+public sealed record StockUsage(string StockId, int Used, int? Remaining);
+
+/// <summary>One physical sheet, with owned ordered placements and immutable stock/settings snapshot.</summary>
+public sealed class NestJobPlateResult
+{
+    public NestJobPlateResult(int plateIndex, NestPlateStock stock, IEnumerable<NestJobPlacement> placements)
+    {
+        ArgumentNullException.ThrowIfNull(stock);
+        PlateIndex = plateIndex;
+        Stock = stock;
+        Placements = NestJob.Own(placements);
+    }
+
+    public int PlateIndex { get; }
+    public string StockId => Stock.Id;
+    public NestPlateStock Stock { get; }
+    public IReadOnlyList<NestJobPlacement> Placements { get; }
+}
+
+/// <summary>Detached result values in commit/input order; no mutable Drawing, Plate, or NestItem escapes.</summary>
+public sealed class NestJobResult
+{
+    public NestJobResult(NestJobStatus status, NestJobStopReason stopReason,
+        IEnumerable<NestJobPlateResult> plates, IEnumerable<PartFulfillment> fulfillment,
+        IEnumerable<StockUsage> stockUsage)
+    {
+        Status = status;
+        StopReason = stopReason;
+        Plates = NestJob.Own(plates);
+        Fulfillment = NestJob.Own(fulfillment);
+        StockUsage = NestJob.Own(stockUsage);
+    }
+
+    public NestJobStatus Status { get; }
+    public NestJobStopReason StopReason { get; }
+    public IReadOnlyList<NestJobPlateResult> Plates { get; }
+    public IReadOnlyList<PartFulfillment> Fulfillment { get; }
+    public IReadOnlyList<StockUsage> StockUsage { get; }
+}

OpenNest.Engine/Jobs/NestJobRunner.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>
+/// Physical-sheet allocation. Every available stock entry is tried independently and only the selected
+/// candidate changes demand or inventory accounting.
+/// </summary>
+public sealed class NestJobRunner : INestingEngine
+{
+    private readonly Func<string, IPlateNester> plateNesterFactory;
+
+    /// <summary>Runner-local strategy resolution. A factory must reject unknown keys or return null.</summary>
+    public NestJobRunner(Func<string, IPlateNester> plateNesterFactory)
+    {
+        ArgumentNullException.ThrowIfNull(plateNesterFactory);
+        this.plateNesterFactory = plateNesterFactory;
+    }
+
+    public NestJobResult Solve(NestJob job, IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default)
+    {
+        ArgumentNullException.ThrowIfNull(job);
+        token.ThrowIfCancellationRequested();
+        NestJobValidator.Validate(job);
+        var plates = new List<NestJobPlateResult>();
+        var remaining = job.Parts.ToDictionary(part => part.Id, part => part.Quantity, StringComparer.Ordinal);
+        var placed = job.Parts.ToDictionary(part => part.Id, _ => 0, StringComparer.Ordinal);
+        var parts = job.Parts.ToDictionary(part => part.Id, StringComparer.Ordinal);
+        var used = job.Plates.ToDictionary(stock => stock.Id, _ => 0, StringComparer.Ordinal);
+        var comparer = new NestJobCandidateComparer(job.Parts);
+        var nester = job.Parts.Count == 0 ? null : plateNesterFactory(job.Options.PlacementStrategy) ??
+            throw new NotSupportedException($"Unknown placement strategy: {job.Options.PlacementStrategy}.");
+        var reason = NestJobStopReason.Completed;
+        while (remaining.Values.Any(count => count > 0))
+        {
+            token.ThrowIfCancellationRequested();
+            if (job.Options.MaxPlates <= plates.Count)
+            {
+                reason = NestJobStopReason.PlateLimitReached;
+                break;
+            }
+
+            CandidateTrial winner = null;
+            var hasAvailableStock = false;
+            for (var index = 0; index < job.Plates.Count; index++)
+            {
+                var stock = job.Plates[index];
+                if (stock.Quantity is int quantity && used[stock.Id] >= quantity) continue;
+                hasAvailableStock = true;
+                var request = new PlatePlacementRequest(stock, job.Parts.Where(part => remaining[part.Id] > 0)
+                    .Select(part => new NestJobPart(part.Id, part.Geometry, remaining[part.Id], part.Priority, part.Rotation)));
+                progress?.Report(new NestJobProgress(NestJobStage.EvaluatingCandidate, stock.Id,
+                    plates.Count, plates.Count, placed.Values.Sum()));
+                token.ThrowIfCancellationRequested();
+                var candidateProgress = progress == null ? null : new CandidateProgress(progress, stock.Id,
+                    plates.Count, plates.Count, placed.Values.Sum());
+                var candidate = nester.Place(request, candidateProgress, token);
+                token.ThrowIfCancellationRequested();
+                NestJobValidator.ValidateCandidate(candidate, stock, remaining, parts);
+                var trial = new CandidateTrial(candidate, stock, index);
+                if (winner == null || comparer.Compare(trial.Candidate, trial.Stock, trial.StockIndex,
+                    winner.Candidate, winner.Stock, winner.StockIndex) > 0)
+                    winner = trial;
+            }
+
+            if (!hasAvailableStock)
+            {
+                reason = NestJobStopReason.StockExhausted;
+                break;
+            }
+            if (winner.Candidate.Placements.Count == 0)
+            {
+                reason = NestJobStopReason.NoPlacementFound;
+                break;
+            }
+
+            var committed = new List<NestJobPlacement>();
+            foreach (var pose in winner.Candidate.Placements)
+            {
+                committed.Add(pose with { InstanceIndex = placed[pose.PartId]++ });
+                remaining[pose.PartId]--;
+            }
+            used[winner.Stock.Id]++;
+            plates.Add(new NestJobPlateResult(plates.Count, winner.Stock, committed));
+            progress?.Report(new NestJobProgress(NestJobStage.PlateCommitted, winner.Stock.Id,
+                plates.Count - 1, plates.Count, placed.Values.Sum()));
+        }
+
+        token.ThrowIfCancellationRequested();
+        return new NestJobResult(reason == NestJobStopReason.Completed ? NestJobStatus.Complete : NestJobStatus.Incomplete,
+            reason, plates, job.Parts.Select(part => new PartFulfillment(part.Id, part.Quantity, placed[part.Id], remaining[part.Id])),
+            job.Plates.Select(stock => new StockUsage(stock.Id, used[stock.Id],
+                stock.Quantity is int quantity ? quantity - used[stock.Id] : null)));
+    }
+
+    private sealed record CandidateTrial(PlateCandidate Candidate, NestPlateStock Stock, int StockIndex);
+
+    private sealed class CandidateProgress(IProgress<NestJobProgress> progress, string stockId, int plateIndex,
+        int committedPlates, int committedParts) : IProgress<NestJobProgress>
+    {
+        public void Report(NestJobProgress value)
+        {
+            ArgumentNullException.ThrowIfNull(value);
+            progress.Report(new NestJobProgress(NestJobStage.EvaluatingCandidate, stockId, plateIndex,
+                committedPlates, committedParts, value.LegacyProgress));
+        }
+    }
+}

OpenNest.Engine/Jobs/NestJobValidator.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest;
+
+/// <summary>Basic input and candidate accounting checks, NOT a geometry/clearance safety gate.</summary>
+public static class NestJobValidator
+{
+    public static void Validate(NestJob job)
+    {
+        ArgumentNullException.ThrowIfNull(job);
+        foreach (var stock in job.Plates)
+        {
+            var edges = stock.EdgeSpacing;
+            if (!Positive(stock.Size.Width) || !Positive(stock.Size.Length) ||
+                !Nonnegative(stock.PartSpacing) || !Nonnegative(edges.Left) || !Nonnegative(edges.Right) ||
+                !Nonnegative(edges.Top) || !Nonnegative(edges.Bottom) || stock.Quadrant < 1 || stock.Quadrant > 4 ||
+                edges.Left + edges.Right >= stock.Size.Length || edges.Top + edges.Bottom >= stock.Size.Width)
+                throw new ArgumentException($"Invalid stock dimensions/settings: {stock.Id}.", nameof(job));
+        }
+        foreach (var part in job.Parts)
+        {
+            if (part.Geometry.Motions.Count == 0 || part.Geometry.Motions.Any(m =>
+                !double.IsFinite(m.X) || !double.IsFinite(m.Y) ||
+                !double.IsFinite(m.CenterX) || !double.IsFinite(m.CenterY)))
+                throw new ArgumentException($"Geometry must contain finite motions: {part.Id}.", nameof(job));
+            try
+            {
+                NestJobPlacementValidator.ValidateGeometry(part.Geometry);
+            }
+            catch (ArgumentException exception)
+            {
+                throw new ArgumentException($"Geometry must contain usable closed edges: {part.Id}.", nameof(job), exception);
+            }
+        }
+    }
+
+    internal static void ValidateCandidate(PlateCandidate candidate, NestPlateStock stock,
+        IReadOnlyDictionary<string, int> remaining, IReadOnlyDictionary<string, NestJobPart> parts)
+    {
+        NestJobPlacementValidator.ValidateCandidate(candidate, stock, remaining, parts);
+    }
+
+    private static bool Positive(double value) => double.IsFinite(value) && value > 0;
+    private static bool Nonnegative(double value) => double.IsFinite(value) && value >= 0;
+}

OpenNest.Engine/Jobs/NestPlateStock.cs

@@ -0,0 +1,29 @@
+using System;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+/// <summary>Immutable stock settings. Size and spacing are copied value types, not caller-owned settings.</summary>
+public sealed class NestPlateStock
+{
+    public NestPlateStock(string id, Size size, int? quantity = null, double partSpacing = 0,
+        Spacing edgeSpacing = default, int quadrant = 1)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(id);
+        if (quantity < 0) throw new ArgumentOutOfRangeException(nameof(quantity));
+        Id = id;
+        Size = size;
+        Quantity = quantity;
+        PartSpacing = partSpacing;
+        EdgeSpacing = edgeSpacing;
+        Quadrant = quadrant;
+    }
+
+    public string Id { get; }
+    public Size Size { get; }
+    /// <summary>Available physical sheets: null is unlimited, zero is legal but unavailable.</summary>
+    public int? Quantity { get; }
+    public double PartSpacing { get; }
+    public Spacing EdgeSpacing { get; }
+    public int Quadrant { get; }
+}

OpenNest.Engine/Jobs/PartGeometrySnapshot.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenNest.CNC;
+
+namespace OpenNest;
+
+/// <summary>Exact immutable CNC motion values. Rapid moves retain contour/hole boundaries; arcs are not tessellated.</summary>
+public sealed record PartGeometryMotion(CodeType Type, double X, double Y, double CenterX,
+    double CenterY, RotationType Rotation, LayerType Layer, bool Suppressed);
+
+/// <summary>
+/// Owned geometry only: no Drawing, quantity, events, or mutable CNC references are retained.
+/// This initial boundary supports flat rapid/linear/arc programs and rejects other instructions explicitly.
+/// Coordinates and mode are preserved without normalization, rounding, or polygon approximation.
+/// </summary>
+public sealed class PartGeometrySnapshot
+{
+    private PartGeometrySnapshot(Mode mode, IEnumerable<PartGeometryMotion> motions)
+    {
+        Mode = mode;
+        Motions = NestJob.Own(motions);
+    }
+
+    public Mode Mode { get; }
+    public IReadOnlyList<PartGeometryMotion> Motions { get; }
+
+    /// <summary>Copies supported motion geometry immediately; later program edits cannot affect this snapshot.</summary>
+    public static PartGeometrySnapshot FromProgram(Program program)
+    {
+        ArgumentNullException.ThrowIfNull(program);
+        var motions = program.Codes.Select(code => code switch
+        {
+            ArcMove arc => new PartGeometryMotion(arc.Type, arc.EndPoint.X, arc.EndPoint.Y,
+                arc.CenterPoint.X, arc.CenterPoint.Y, arc.Rotation, arc.Layer, arc.Suppressed),
+            LinearMove line => new PartGeometryMotion(line.Type, line.EndPoint.X, line.EndPoint.Y,
+                0, 0, default, line.Layer, line.Suppressed),
+            RapidMove rapid => new PartGeometryMotion(rapid.Type, rapid.EndPoint.X, rapid.EndPoint.Y,
+                0, 0, default, default, rapid.Suppressed),
+            _ => throw new NotSupportedException("Geometry snapshots currently support only flat rapid/linear/arc programs.")
+        });
+        return new PartGeometrySnapshot(program.Mode, motions);
+    }
+}

OpenNest.Engine/Jobs/Placement/DefaultPlateNester.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>
+/// Migrated built-in placement strategy for the whole-job runner. Reuses <see cref="DefaultNestEngine"/>
+/// fill/pack geometry but owns its own run-scoped bookkeeping: remaining demand is read from the
+/// request and placement counts are derived from returned placements, so the engine's private
+/// <see cref="NestItem.Quantity"/> mutations never feed back into job accounting.
+/// </summary>
+/// <remarks>
+/// A private <see cref="Drawing"/> per requirement is created once per solve and reused across every
+/// candidate trial (the runner reuses one <see cref="IPlateNester"/> instance per job). This is safe
+/// because the engines mutate <see cref="NestItem.Quantity"/> (per-trial) and canonical-frame copies,
+/// never the shared <see cref="Drawing"/> or its <c>Quantity</c>. Identity is by Drawing reference,
+/// never by name. Each trial still gets a fresh private <see cref="Plate"/>.
+/// </remarks>
+public sealed class DefaultPlateNester : IPlateNester
+{
+    private readonly Func<Plate, DefaultNestEngine> engineFactory;
+    private readonly Dictionary<string, Drawing> drawingsById = new(StringComparer.Ordinal);
+    private readonly Dictionary<Drawing, string> idByDrawing = new(ReferenceEqualityComparer.Instance);
+
+    public DefaultPlateNester() : this(static plate => new DefaultNestEngine(plate))
+    {
+    }
+
+    /// <param name="engineFactory">Injectable for tests; defaults to <see cref="DefaultNestEngine"/>.</param>
+    public DefaultPlateNester(Func<Plate, DefaultNestEngine> engineFactory)
+    {
+        this.engineFactory = engineFactory ?? throw new ArgumentNullException(nameof(engineFactory));
+    }
+
+    public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        token.ThrowIfCancellationRequested();
+
+        var plate = DrawingJobMapper.CreatePlate(request.Stock);
+        var items = new List<NestItem>(request.Parts.Count);
+        foreach (var requirement in request.Parts)
+        {
+            if (!drawingsById.TryGetValue(requirement.Id, out var drawing))
+            {
+                drawing = DrawingJobMapper.CreateDrawing(requirement);
+                drawingsById.Add(requirement.Id, drawing);
+                idByDrawing.Add(drawing, requirement.Id);
+            }
+
+            // Quantity is the request's remaining demand; the engine may mutate this per-trial item,
+            // and that mutation is deliberately discarded — placement counts come from the result.
+            items.Add(new NestItem
+            {
+                Drawing = drawing,
+                Quantity = requirement.Quantity,
+                Priority = requirement.Priority,
+                StepAngle = DrawingJobMapper.LegacyStep(requirement.Rotation),
+                RotationStart = requirement.Rotation.Start,
+                RotationEnd = requirement.Rotation.End
+            });
+        }
+
+        var engine = engineFactory(plate) ?? throw new InvalidOperationException("Engine factory returned null.");
+        var legacyProgress = CandidateProgressBridge.Create(progress, request.Stock.Id);
+        var parts = engine.Nest(items, legacyProgress, token);
+        token.ThrowIfCancellationRequested();
+        if (parts == null) throw new InvalidOperationException("Engine returned null placements.");
+
+        var placements = new List<NestJobPlacement>(parts.Count);
+        foreach (var part in parts)
+        {
+            if (part?.BaseDrawing == null || !idByDrawing.TryGetValue(part.BaseDrawing, out var id))
+                throw new InvalidOperationException("Placement does not reference a known requirement drawing.");
+            placements.Add(new NestJobPlacement(id, 0, part.Location.X, part.Location.Y, part.Rotation));
+        }
+
+        return new PlateCandidate(placements);
+    }
+}

OpenNest.Engine/Jobs/Placement/StripPlateNester.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>
+/// Migrated built-in placement strategy for the whole-job runner. Reuses <see cref="StripNestEngine"/>
+/// iterative shrink-fill/pack geometry with the same run-scoped bookkeeping as <see cref="DefaultPlateNester"/>:
+/// remaining demand is read from the request and placement counts are derived from returned placements.
+/// </summary>
+/// <remarks>
+/// A private <see cref="Drawing"/> per requirement is created once per solve and reused across trials
+/// (safe: the engine mutates per-trial <see cref="NestItem.Quantity"/> and canonical copies, never the
+/// shared Drawing). Identity is by Drawing reference. Each trial gets a fresh private <see cref="Plate"/>.
+/// </remarks>
+public sealed class StripPlateNester : IPlateNester
+{
+    private readonly Func<Plate, StripNestEngine> engineFactory;
+    private readonly Dictionary<string, Drawing> drawingsById = new(StringComparer.Ordinal);
+    private readonly Dictionary<Drawing, string> idByDrawing = new(ReferenceEqualityComparer.Instance);
+
+    public StripPlateNester() : this(static plate => new StripNestEngine(plate))
+    {
+    }
+
+    /// <param name="engineFactory">Injectable for tests; defaults to <see cref="StripNestEngine"/>.</param>
+    public StripPlateNester(Func<Plate, StripNestEngine> engineFactory)
+    {
+        this.engineFactory = engineFactory ?? throw new ArgumentNullException(nameof(engineFactory));
+    }
+
+    public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        token.ThrowIfCancellationRequested();
+
+        var plate = DrawingJobMapper.CreatePlate(request.Stock);
+        var items = new List<NestItem>(request.Parts.Count);
+        foreach (var requirement in request.Parts)
+        {
+            if (!drawingsById.TryGetValue(requirement.Id, out var drawing))
+            {
+                drawing = DrawingJobMapper.CreateDrawing(requirement);
+                drawingsById.Add(requirement.Id, drawing);
+                idByDrawing.Add(drawing, requirement.Id);
+            }
+
+            items.Add(new NestItem
+            {
+                Drawing = drawing,
+                Quantity = requirement.Quantity,
+                Priority = requirement.Priority,
+                StepAngle = DrawingJobMapper.LegacyStep(requirement.Rotation),
+                RotationStart = requirement.Rotation.Start,
+                RotationEnd = requirement.Rotation.End
+            });
+        }
+
+        var engine = engineFactory(plate) ?? throw new InvalidOperationException("Engine factory returned null.");
+        var legacyProgress = CandidateProgressBridge.Create(progress, request.Stock.Id);
+        var parts = engine.Nest(items, legacyProgress, token);
+        token.ThrowIfCancellationRequested();
+        if (parts == null) throw new InvalidOperationException("Engine returned null placements.");
+
+        var placements = new List<NestJobPlacement>(parts.Count);
+        foreach (var part in parts)
+        {
+            if (part?.BaseDrawing == null || !idByDrawing.TryGetValue(part.BaseDrawing, out var id))
+                throw new InvalidOperationException("Placement does not reference a known requirement drawing.");
+            placements.Add(new NestJobPlacement(id, 0, part.Location.X, part.Location.Y, part.Rotation));
+        }
+
+        return new PlateCandidate(placements);
+    }
+}

OpenNest.Engine/Jobs/PlateCandidate.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace OpenNest;
+
+/// <summary>Owned candidate poses only; not committed fulfillment or inventory accounting.</summary>
+public sealed class PlateCandidate
+{
+    public PlateCandidate(IEnumerable<NestJobPlacement> placements) => Placements = NestJob.Own(placements);
+    public IReadOnlyList<NestJobPlacement> Placements { get; }
+}

OpenNest.Engine/Jobs/PlateNesterFactory.cs

@@ -0,0 +1,24 @@
+using System;
+namespace OpenNest;
+
+/// <summary>
+/// Instance-scoped strategy resolution for the whole-job runner. Default and Strip resolve to the
+/// migrated built-in plate nesters; the remnant strategies still use the legacy adapter during
+/// rollout. The process-global NestEngineRegistry (including plugin registrations and
+/// ActiveEngineName) is neither read nor modified. Unknown keys reject.
+/// </summary>
+public static class PlateNesterFactory
+{
+    public static IPlateNester Create(string strategy)
+    {
+        ArgumentNullException.ThrowIfNull(strategy);
+        return strategy switch
+        {
+            "Default" => new DefaultPlateNester(),
+            "Strip" => new StripPlateNester(),
+            "Vertical Remnant" => new LegacyPlateNesterAdapter(plate => new VerticalRemnantEngine(plate)),
+            "Horizontal Remnant" => new LegacyPlateNesterAdapter(plate => new HorizontalRemnantEngine(plate)),
+            _ => throw new NotSupportedException($"Unknown placement strategy: {strategy}.")
+        };
+    }
+}

OpenNest.Engine/Jobs/PlatePlacementRequest.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+namespace OpenNest;
+
+/// <summary>Read-only stock settings and remaining requirements for a single candidate trial.</summary>
+public sealed class PlatePlacementRequest
+{
+    public PlatePlacementRequest(NestPlateStock stock, IEnumerable<NestJobPart> parts)
+    {
+        ArgumentNullException.ThrowIfNull(stock);
+        Stock = stock;
+        Parts = NestJob.Own(parts);
+    }
+
+    public NestPlateStock Stock { get; }
+    public IReadOnlyList<NestJobPart> Parts { get; }
+}

OpenNest.Engine/Jobs/RotationPolicy.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace OpenNest;
+
+public enum RotationPolicyKind { Fixed, BoundedSweep, Automatic }
+
+/// <summary>Immutable rotation constraints, in radians about the geometry origin.</summary>
+public sealed class RotationPolicy
+{
+    private RotationPolicy(RotationPolicyKind kind, double start, double end, double step)
+    {
+        if (!double.IsFinite(start) || !double.IsFinite(end) || !double.IsFinite(step))
+            throw new ArgumentException("Angles must be finite.");
+        Kind = kind;
+        Start = start;
+        End = end;
+        Step = step;
+    }
+
+    public RotationPolicyKind Kind { get; }
+    public double Start { get; }
+    public double End { get; }
+    public double Step { get; }
+    public static RotationPolicy Automatic { get; } = new(RotationPolicyKind.Automatic, 0, 0, 0);
+    public static RotationPolicy Fixed(double angle) => new(RotationPolicyKind.Fixed, angle, angle, 0);
+    public static RotationPolicy BoundedSweep(double start, double end, double step)
+    {
+        if (step <= 0 || end < start) throw new ArgumentException("Sweep needs a positive step and ordered bounds.");
+        return new RotationPolicy(RotationPolicyKind.BoundedSweep, start, end, step);
+    }
+
+    /// <summary>Preserves the legacy zero-step automatic sentinel; zero never means locked rotation.</summary>
+    public static RotationPolicy FromLegacy(double stepAngle, double rotationStart, double rotationEnd) =>
+        stepAngle == 0 ? Automatic : BoundedSweep(rotationStart, rotationEnd, stepAngle);
+}

OpenNest.Engine/ML/FeatureExtractor.cs

@@ -27,7 +27,10 @@ namespace OpenNest.Engine.ML
     {
         public static PartFeatures Extract(Drawing drawing)
         {
-            var entities = OpenNest.Converters.ConvertProgram.ToGeometry(drawing.Program)
+            // Normalize to canonical frame so features are invariant to import orientation.
+            var canonical = CanonicalFrame.AsCanonicalCopy(drawing);
+
+            var entities = OpenNest.Converters.ConvertProgram.ToGeometry(canonical.Program)
                 .Where(e => e.Layer != SpecialLayers.Rapid)
                 .ToList();
 
@@ -45,18 +48,18 @@ namespace OpenNest.Engine.ML
 
             var features = new PartFeatures
             {
-                Area = drawing.Area,
-                Convexity = drawing.Area / (hullArea > 0 ? hullArea : 1.0),
+                Area = canonical.Area,
+                Convexity = canonical.Area / (hullArea > 0 ? hullArea : 1.0),
                 AspectRatio = bb.Length / (bb.Width > 0 ? bb.Width : 1.0),
-                BoundingBoxFill = drawing.Area / (bb.Area() > 0 ? bb.Area() : 1.0),
+                BoundingBoxFill = canonical.Area / (bb.Area() > 0 ? bb.Area() : 1.0),
                 VertexCount = polygon.Vertices.Count,
                 Bitmask = GenerateBitmask(polygon, 32)
             };
 
             // Circularity = 4 * PI * Area / Perimeter^2
             var perimeterLen = polygon.Perimeter();
-            features.Circularity = (4 * System.Math.PI * drawing.Area) / (perimeterLen * perimeterLen);
-            features.PerimeterToAreaRatio = drawing.Area > 0 ? perimeterLen / drawing.Area : 0;
+            features.Circularity = (4 * System.Math.PI * canonical.Area) / (perimeterLen * perimeterLen);
+            features.PerimeterToAreaRatio = canonical.Area > 0 ? perimeterLen / canonical.Area : 0;
 
             return features;
         }

OpenNest.Engine/NestEngineBase.cs

@@ -113,11 +113,11 @@ namespace OpenNest
                 {
                     allParts.AddRange(fillParts);
 
-                    // Deduct placed quantities
+                    // Deduct placed quantities by drawing reference, not name.
                     foreach (var item in fillItems)
                     {
                         var placed = fillParts.Count(p =>
-                            p.BaseDrawing.Name == item.Drawing.Name);
+                            ReferenceEquals(p.BaseDrawing, item.Drawing));
                         item.Quantity = System.Math.Max(0, item.Quantity - placed);
                     }
 
@@ -147,10 +147,11 @@ namespace OpenNest
                 {
                     allParts.AddRange(packParts);
 
+                    // Deduct placed quantities by drawing reference, not name.
                     foreach (var item in regularPackItems)
                     {
                         var placed = packParts.Count(p =>
-                            p.BaseDrawing.Name == item.Drawing.Name);
+                            ReferenceEquals(p.BaseDrawing, item.Drawing));
                         item.Quantity = System.Math.Max(0, item.Quantity - placed);
                     }
                 }
@@ -334,6 +335,12 @@ namespace OpenNest
                 var bestFits = BestFitCache.GetOrCompute(
                     item.Drawing, Plate.Size.Length, Plate.Size.Width, Plate.PartSpacing);
 
+                // BestFitCache stores pair coordinates in canonical frame. Build candidates
+                // from a canonical drawing copy so geometry and coords share a frame; rebind
+                // + un-rotate winning pair to the original drawing's frame before returning.
+                var canonicalDrawing = CanonicalFrame.AsCanonicalCopy(item.Drawing);
+                var sourceAngle = item.Drawing?.Source?.Angle ?? 0.0;
+
                 List<Part> bestPlacement = null;
                 Box bestTarget = null;
 
@@ -342,7 +349,7 @@ namespace OpenNest
                     if (!fit.Keep)
                         continue;
 
-                    var parts = fit.BuildParts(item.Drawing);
+                    var parts = fit.BuildParts(canonicalDrawing);
                     var pairBbox = ((IEnumerable<IBoundable>)parts).GetBoundingBox();
                     var pairW = pairBbox.Width;
                     var pairL = pairBbox.Length;
@@ -374,6 +381,10 @@ namespace OpenNest
 
                 if (bestPlacement == null) continue;
 
+                // Rebind to the original drawing and compose sourceAngle onto rotation so the
+                // final placed parts sit in the user's visible frame.
+                bestPlacement = RebindPairToOriginal(bestPlacement, item.Drawing, sourceAngle);
+
                 result.AddRange(bestPlacement);
                 item.Quantity = 0;
 
@@ -388,6 +399,30 @@ namespace OpenNest
             return result;
         }
 
+        /// <summary>
+        /// Rebinds each canonical-frame Part in the pair to the original Drawing at its current
+        /// world pose, then composes sourceAngle onto each via CanonicalFrame.FromCanonical so
+        /// the returned list is in the original drawing's visible frame. Mirrors
+        /// DefaultNestEngine.RebindAndUnCanonicalize.
+        /// </summary>
+        private static List<Part> RebindPairToOriginal(List<Part> parts, Drawing original, double sourceAngle)
+        {
+            if (parts == null || parts.Count == 0)
+                return parts;
+
+            for (var i = 0; i < parts.Count; i++)
+            {
+                var p = parts[i];
+                var rebound = Part.CreateAtOrigin(original, p.Rotation);
+                var delta = p.BoundingBox.Location - rebound.BoundingBox.Location;
+                rebound.Offset(delta);
+                rebound.UpdateBounds();
+                parts[i] = rebound;
+            }
+
+            return CanonicalFrame.FromCanonical(parts, sourceAngle);
+        }
+
         /// <summary>
         /// Determines whether a drawing should use grid-fill (true) or bin-pack (false).
         /// Low-quantity items whose total area is a small fraction of the plate are