fix(engine): reject small corner overlaps in placement validation

The witness-probe overlap test missed small corner intersections: its
candidate points (crossing-edge midpoints and vertex-centroid midpoints)
can all land on a part boundary or outside the intersection, so two 10x10
parts at (0,0) and (9,9) with zero spacing were accepted despite sharing
a 1x1 unit of material.

Route the overlap decision through Collision, which clips triangulated
polygons and keeps only positive-area regions, catching corner overlaps,
containment, and coincident poses while legal edge/corner contact stays
legal. Collision's hole subtraction was conservative (partially-clipped
triangles were kept whole), so a part inside another part's cutout could
false-positive depending on triangulation alignment; subtract holes
exactly instead: a piece outside a convex hole triangle is the union of
its clips against each edge's outside half-space.

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,16 @@ 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 `INestingEngine` implementations against each other on real `.nest` files. Each engine solves the whole job — it owns its own multi-plate/size strategy rather than being handed one already-sized plate at a time. Fully generic — it never hardcodes drawing geometry, just reads whatever drawings/quantities/plate settings each input file already has.
+
+- `JobLoader` builds `BenchmarkJob`s from a `.nest` file or a folder of them via `NestReader`, using every drawing with `Quantity.Required > 0`. `--sheet-sizes` can sweep a fixed list of plate sizes instead of each file's own.
+- `BenchmarkJob.BuildNestJob(maxPlates)` converts the job into a `NestJob`: one `NestJobPart` per requested drawing (via `DrawingJobMapper.FromDrawing`) and one `NestPlateStock` per candidate sheet size (unlimited quantity — the engine decides how many of each size it uses).
+- `BenchmarkRunner` calls each engine's `INestingEngine.Solve(NestJob)` once per job, under a wall-clock timeout so a runaway or hanging engine can't stall the whole benchmark run, then materializes the result back into legacy `Plate`/`Part` objects via `NestResultMaterializer` for scoring.
+- `NestValidator` checks the returned layout: every part inside `Plate.WorkArea()`, every pair at least `Plate.PartSpacing` apart (checked geometrically 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, throwing, or timed-out 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 fewer plates used (`Report`'s ranking rule) — using fewer sheets to do the same job wastes less material.
+- `--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.Benchmark/BenchmarkJob.cs

@@ -0,0 +1,60 @@
+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>
+        /// Builds the whole-job request this job represents: one NestJobPart per
+        /// requested drawing, and one NestPlateStock per candidate sheet size
+        /// (unlimited quantity - the engine under test decides how many of each
+        /// size it actually uses, and how demand splits across plates). The
+        /// engine owns its own multi-plate/size strategy; this harness no
+        /// longer picks plate sizes on the engine's behalf.
+        /// </summary>
+        public NestJob BuildNestJob(int maxPlates, double salvageRate = 0, double minimumSalvageDimension = 0)
+        {
+            var parts = Requests.Select(r =>
+                DrawingJobMapper.FromDrawing(r.Drawing.Id.ToString(), r.Drawing, r.Quantity));
+            var stock = CandidateSizes.Select(size =>
+                new NestPlateStock(size.ToString(1), size, null, PartSpacing, EdgeSpacing, Quadrant));
+            return new NestJob(parts, stock, new NestJobOptions("Default", maxPlates, salvageRate, minimumSalvageDimension));
+        }
+    }
+}

OpenNest.Benchmark/BenchmarkRunner.cs

@@ -0,0 +1,149 @@
+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. Each engine is a full
+    /// INestingEngine: it owns its own plate/size selection and multi-plate
+    /// strategy for the whole job, rather than being handed one already-sized
+    /// plate at a time by this harness. A per-run timeout guards against a
+    /// runaway or hanging engine — cooperative cancellation, so it reliably
+    /// stops engines built on NestJobRunner (all four built-ins) but can't
+    /// forcibly interrupt an engine that never checks its token.
+    /// </summary>
+    public static class BenchmarkRunner
+    {
+        /// <summary>Physical-sheet cap passed to every job's NestJobOptions.MaxPlates.</summary>
+        private const int MaxPlates = 40;
+
+        /// <summary>Wall-clock budget for one engine solving one job.</summary>
+        private static readonly TimeSpan SolveTimeout = TimeSpan.FromMinutes(5);
+
+        public static List<JobResult> Run(List<BenchmarkJob> jobs, IReadOnlyList<NestingEngineInfo> engines,
+            double salvageRate = 0, double minimumSalvageDimension = 0, string outputDirectory = null)
+        {
+            var results = new List<JobResult>(jobs.Count * engines.Count);
+
+            foreach (var job in jobs)
+            {
+                foreach (var engineInfo in engines)
+                {
+                    results.Add(RunOne(job, engineInfo, salvageRate, minimumSalvageDimension, outputDirectory));
+                }
+            }
+
+            return results;
+        }
+
+        private static JobResult RunOne(BenchmarkJob job, NestingEngineInfo engineInfo,
+            double salvageRate, double minimumSalvageDimension, string outputDirectory)
+        {
+            var requested = job.TotalRequestedQuantity;
+            var sw = Stopwatch.StartNew();
+
+            try
+            {
+                var nestJob = job.BuildNestJob(MaxPlates, salvageRate, minimumSalvageDimension);
+                var engine = engineInfo.Factory();
+                using var cts = new CancellationTokenSource(SolveTimeout);
+                var jobResult = engine.Solve(nestJob, null, cts.Token);
+
+                var materialized = NestResultMaterializer.Materialize(nestJob, jobResult);
+                var plateRuns = materialized.Nest.Plates
+                    .Select(plate => (Plate: plate, Parts: plate.Parts.ToList()))
+                    .ToList();
+
+                var requirements = job.Requests.ToDictionary<DrawingRequest, Drawing, (string Name, int Quantity)>(
+                    r => materialized.DrawingsByPartId[r.Drawing.Id.ToString()],
+                    r => (r.Drawing.Name, r.Quantity),
+                    ReferenceEqualityComparer.Instance);
+
+                var validation = NestValidator.Validate(plateRuns, requirements);
+                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());
+
+                if (validation.Valid && outputDirectory != null)
+                {
+                    System.IO.Directory.CreateDirectory(outputDirectory);
+                    // Keep names and job metadata for a useful inspectable output; never modify source.
+                    var source = new OpenNest.IO.NestReader(job.SourceFile).Read();
+                    materialized.Nest.Name = source.Name;
+                    materialized.Nest.Units = source.Units;
+                    materialized.Nest.Material = source.Material;
+                    materialized.Nest.Thickness = source.Thickness;
+                    materialized.Nest.SalvageRate = salvageRate;
+                    foreach (var request in job.Requests)
+                        materialized.DrawingsByPartId[request.Drawing.Id.ToString()].Name = request.Drawing.Name;
+                    var path = System.IO.Path.Combine(outputDirectory, $"{job.Name}-{engineInfo.Name}.nest");
+                    if (System.IO.Path.GetFullPath(path) == System.IO.Path.GetFullPath(job.SourceFile))
+                        throw new InvalidOperationException("Output must not overwrite the source nest.");
+                    new OpenNest.IO.NestWriter(materialized.Nest).Write(path);
+                    var report = new
+                    {
+                        Source = job.SourceFile, Engine = engineInfo.Name, jobResult.Status, jobResult.StopReason,
+                        Requested = requested, Placed = totalPlaced, SheetArea = plateArea, PlacedArea = placedArea,
+                        SalvageRate = salvageRate, MinimumSalvageDimension = minimumSalvageDimension,
+                        EstimatedNetArea = jobResult.Plates.Sum(p => StockLadderNestingEngine.EstimateNetArea(nestJob, p)),
+                        Fulfillment = jobResult.Fulfillment, StockUsage = jobResult.StockUsage,
+                        Plates = jobResult.Plates, validation.Violations
+                    };
+                    System.IO.File.WriteAllText(System.IO.Path.ChangeExtension(path, ".json"),
+                        System.Text.Json.JsonSerializer.Serialize(report,
+                            new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));
+                }
+                sw.Stop();
+
+                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,
+                };
+            }
+            catch (OperationCanceledException)
+            {
+                sw.Stop();
+                return new JobResult
+                {
+                    EngineName = engineInfo.Name,
+                    JobName = job.Name,
+                    Valid = false,
+                    PartsRequested = requested,
+                    ElapsedMs = sw.ElapsedMilliseconds,
+                    Error = $"Timed out after {SolveTimeout.TotalMinutes:F0} minute(s)",
+                };
+            }
+            catch (Exception ex)
+            {
+                sw.Stop();
+                return new JobResult
+                {
+                    EngineName = engineInfo.Name,
+                    JobName = job.Name,
+                    Valid = false,
+                    PartsRequested = requested,
+                    ElapsedMs = sw.ElapsedMilliseconds,
+                    Error = $"{ex.GetType().Name}: {ex.Message}",
+                };
+            }
+        }
+    }
+}

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,198 @@
+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
+    {
+        /// <summary>
+        /// requirements maps each materialized part's BaseDrawing (by reference - materialized
+        /// Drawing instances are freshly reconstructed per NestResultMaterializer.Materialize, so
+        /// identity must never be inferred from Name, which is only incidentally seeded from the
+        /// originating NestJobPart id) to its original quantity limit and display name.
+        /// </summary>
+        public static ValidationResult Validate(List<(Plate Plate, List<Part> Parts)> plateRuns,
+            IReadOnlyDictionary<Drawing, (string Name, int Quantity)> requirements)
+        {
+            var result = new ValidationResult();
+            var allParts = plateRuns.SelectMany(pr => pr.Parts).ToList();
+
+            if (allParts.Count == 0)
+                return result;
+
+            ValidateQuantities(allParts, requirements, result);
+
+            foreach (var (plate, parts) in plateRuns)
+            {
+                if (parts.Count == 0)
+                    continue;
+
+                ValidateBounds(parts, plate, requirements, result);
+                ValidateAreaBudget(parts, plate, result);
+                ValidateSpacing(parts, plate.PartSpacing, requirements, result);
+            }
+
+            return result;
+        }
+
+        private static void ValidateQuantities(List<Part> parts,
+            IReadOnlyDictionary<Drawing, (string Name, int Quantity)> requirements, ValidationResult result)
+        {
+            var placedCounts = parts
+                .GroupBy<Part, Drawing>(p => p.BaseDrawing, ReferenceEqualityComparer.Instance)
+                .ToDictionary(g => g.Key, g => g.Count());
+
+            foreach (var (drawing, placed) in placedCounts)
+            {
+                if (!requirements.TryGetValue(drawing, out var requirement))
+                {
+                    result.Violations.Add($"Placed drawing '{drawing.Name}' which was not requested for this job");
+                    continue;
+                }
+
+                if (placed > requirement.Quantity)
+                {
+                    result.Violations.Add(
+                        $"'{requirement.Name}': placed {placed} across all plates but only {requirement.Quantity} were requested");
+                }
+            }
+        }
+
+        private static void ValidateBounds(List<Part> parts, Plate plate,
+            IReadOnlyDictionary<Drawing, (string Name, int Quantity)> requirements, 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(
+                        $"'{DisplayName(part, requirements)}' 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,
+            IReadOnlyDictionary<Drawing, (string Name, int Quantity)> requirements, 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(
+                            $"'{DisplayName(parts[i], requirements)}' and '{DisplayName(parts[j], requirements)}' are closer than the required spacing ({spacing:F3})");
+                    }
+                }
+            }
+        }
+
+        /// <summary>Friendly name for a violation message, falling back to the materialized
+        /// Drawing's own Name (the raw partId string) if this part wasn't in requirements at all -
+        /// that mismatch is already reported by ValidateQuantities, so this is display-only.</summary>
+        private static string DisplayName(Part part, IReadOnlyDictionary<Drawing, (string Name, int Quantity)> requirements) =>
+            requirements.TryGetValue(part.BaseDrawing, out var requirement) ? requirement.Name : part.BaseDrawing.Name;
+
+        /// <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,192 @@
+using OpenNest;
+using OpenNest.Benchmark;
+using OpenNest.Geometry;
+using System;
+using System.Collections.Generic;
+using System.IO;
+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 enginesDir = Path.Combine(AppContext.BaseDirectory, "Engines");
+        NestingEngineRegistry.LoadPlugins(enginesDir);
+
+        var engines = NestingEngineRegistry.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(", ", NestingEngineRegistry.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, options.SalvageRate, options.MinimumSalvageDimension, options.OutputDirectory);
+
+        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 "--salvage-rate" when i + 1 < args.Length:
+                    o.SalvageRate = double.Parse(args[++i], System.Globalization.CultureInfo.InvariantCulture);
+                    break;
+                case "--min-salvage-dimension" when i + 1 < args.Length:
+                    o.MinimumSalvageDimension = double.Parse(args[++i], System.Globalization.CultureInfo.InvariantCulture);
+                    break;
+                case "--output" when i + 1 < args.Length:
+                    o.OutputDirectory = 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.Distinct().ToList();
+    }
+
+    private static void PrintUsage()
+    {
+        Console.Error.WriteLine("OpenNest.Benchmark - compare registered whole-job 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 INestingEngine. Each engine is handed the full job - every");
+        Console.Error.WriteLine("requested part and the whole pool of candidate sheet sizes - and owns its own");
+        Console.Error.WriteLine("multi-plate/size strategy: how many plates it uses, of which sizes, and how");
+        Console.Error.WriteLine("demand splits across them. Scoring: aggregate material utilization across every");
+        Console.Error.WriteLine("plate used, then (if everything requested was placed) fewer plates as the");
+        Console.Error.WriteLine("tie-break. An invalid layout (out of bounds, overlapping, or over-quantity), a");
+        Console.Error.WriteLine("thrown exception, or a run exceeding its time budget all score 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("  --salvage-rate <0..1>           Fraction of eligible offcut area credited (default 0)");
+        Console.Error.WriteLine("  --min-salvage-dimension <value> Both offcut dimensions must qualify; 0 disables credit");
+        Console.Error.WriteLine("  --output <directory>           Save valid layouts as .nest plus detailed JSON reports");
+        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;
+        public string OutputDirectory;
+        public double SalvageRate;
+        public double MinimumSalvageDimension;
+    }
+}

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.Core/Geometry/Collision.cs

@@ -286,8 +286,10 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Subtracts hole triangles from a region. Conservative: partial overlaps
-        /// keep the full piece triangle (acceptable for visual shading).
+        /// Subtracts hole triangles from a region. Exact: a piece outside a convex hole
+        /// triangle equals the union of its clips against each triangle edge's outside
+        /// half-space, so overlap confined to a cutout disappears while any material
+        /// sliver outside the hole survives.
         /// </summary>
         private static List<Polygon> SubtractTriangles(Polygon region, List<Polygon> holeTris)
         {
@@ -295,29 +297,25 @@ namespace OpenNest.Geometry
 
             foreach (var holeTri in holeTris)
             {
-                if (!BoundingBoxesOverlap(region.BoundingBox, holeTri.BoundingBox))
-                    continue;
-
                 var next = new List<Polygon>();
 
                 foreach (var piece in current)
                 {
-                    var pieceTris = TriangulateWithBounds(piece);
-
-                    foreach (var pieceTri in pieceTris)
+                    if (!BoundingBoxesOverlap(piece.BoundingBox, holeTri.BoundingBox))
                     {
-                        var inside = ClipConvex(pieceTri, holeTri);
-                        if (inside == null)
-                        {
-                            // No overlap with hole - keep
-                            next.Add(pieceTri);
-                        }
-                        else if (inside.Area() < pieceTri.Area() - Tolerance.Epsilon)
-                        {
-                            // Partial overlap - keep the piece (conservative)
-                            next.Add(pieceTri);
-                        }
-                        // else: fully inside hole - discard
+                        next.Add(piece);
+                        continue;
+                    }
+
+                    foreach (var pieceTri in TriangulateWithBounds(piece))
+                    {
+                        var holeVerts = holeTri.Vertices;
+                        var holeCount = holeTri.IsClosed() ? holeVerts.Count - 1 : holeVerts.Count;
+                        var survived = false;
+                        for (var i = 0; i < holeCount; i++)
+                            survived |= AddIfPositiveArea(next,
+                                ClipOutsideHalfSpace(pieceTri, holeVerts[i], holeVerts[(i + 1) % holeCount]));
+                        if (!survived) continue; // piece lies entirely within the hole
                     }
                 }
 
@@ -326,5 +324,40 @@ namespace OpenNest.Geometry
 
             return current;
         }
+
+        /// <summary>
+        /// Sutherland-Hodgman clip of a convex polygon to the strict outside of the
+        /// infinite line edgeStart->edgeEnd of a CCW hole edge (Cross &lt; -Epsilon).
+        /// </summary>
+        private static List<Vector> ClipOutsideHalfSpace(Polygon piece, Vector edgeStart, Vector edgeEnd)
+        {
+            var verts = piece.Vertices;
+            var count = piece.IsClosed() ? verts.Count - 1 : verts.Count;
+            var kept = new List<Vector>();
+            for (var i = 0; i < count; i++)
+            {
+                var current = verts[i];
+                var next = verts[(i + 1) % count];
+                var currentInside = Cross(edgeStart, edgeEnd, current) >= -Tolerance.Epsilon;
+                var nextInside = Cross(edgeStart, edgeEnd, next) >= -Tolerance.Epsilon;
+                if (!currentInside) kept.Add(current);
+                if (currentInside == nextInside) continue;
+                var intersection = LineIntersection(edgeStart, edgeEnd, current, next);
+                if (intersection.IsValid()) kept.Add(intersection);
+            }
+            return kept;
+        }
+
+        private static bool AddIfPositiveArea(List<Polygon> polygons, List<Vector> vertices)
+        {
+            if (vertices.Count < 3) return false;
+            var polygon = new Polygon();
+            polygon.Vertices.AddRange(vertices);
+            polygon.Close();
+            polygon.UpdateBounds();
+            if (polygon.Area() <= Tolerance.Epsilon) return false;
+            polygons.Add(polygon);
+            return true;
+        }
     }
 }

OpenNest.Engine.Tests/Fill/SortStripsTests.cs

@@ -0,0 +1,46 @@
+using OpenNest.Engine.Fill;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Fill;
+
+public class SortStripsTests
+{
+    private static Part MakeRectPart(double x, double y, double w, double h)
+    {
+        var pgm = new OpenNest.CNC.Program();
+        pgm.Codes.Add(new OpenNest.CNC.RapidMove(new Vector(0, 0)));
+        pgm.Codes.Add(new OpenNest.CNC.LinearMove(new Vector(w, 0)));
+        pgm.Codes.Add(new OpenNest.CNC.LinearMove(new Vector(w, h)));
+        pgm.Codes.Add(new OpenNest.CNC.LinearMove(new Vector(0, h)));
+        pgm.Codes.Add(new OpenNest.CNC.LinearMove(new Vector(0, 0)));
+        var drawing = new Drawing("rect", pgm);
+        return new Part(drawing, new Vector(x, y));
+    }
+
+    [Fact]
+    public void SortColumnsByHeight_NonUniformGaps_DoesNotExceedOriginalSpan()
+    {
+        // Three columns with non-uniform gaps between them (5, then 1) and heights
+        // ordered so the sort-by-height pass must reorder them (tallest first, then
+        // shortest, then medium). The tallest column's original position leaves a
+        // 5-unit gap to its neighbor; that single sampled gap must not get replayed
+        // as the spacing for the whole staircase once it's no longer the leading pair.
+        var tall = MakeRectPart(0, 0, 10, 30);    // Left 0-10,  gap of 5 to next
+        var shortCol = MakeRectPart(15, 0, 5, 5); // Left 15-20, gap of 1 to next
+        var medium = MakeRectPart(21, 0, 20, 15); // Left 21-41
+
+        var originalRight = new[] { tall, shortCol, medium }.Max(p => p.BoundingBox.Right);
+        var originalLeft = new[] { tall, shortCol, medium }.Min(p => p.BoundingBox.Left);
+        var originalSpan = originalRight - originalLeft;
+
+        var parts = new List<Part> { tall, shortCol, medium };
+        IterativeShrinkFiller.SortColumnsByHeight(parts, spacing: 1.0);
+
+        var newRight = parts.Max(p => p.BoundingBox.Right);
+        var newLeft = parts.Min(p => p.BoundingBox.Left);
+        var newSpan = newRight - newLeft;
+
+        Assert.True(newSpan <= originalSpan + 1e-9,
+            $"Resequenced columns must not exceed the original footprint: original span {originalSpan}, new span {newSpan}");
+    }
+}

OpenNest.Engine.Tests/Jobs/FixedStrategyNestingEngineTests.cs

@@ -0,0 +1,43 @@
+using OpenNest.Geometry;
+using Xunit;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class FixedStrategyNestingEngineTests
+{
+    [Fact]
+    public void ForcesConfiguredStrategyRegardlessOfJobOptions()
+    {
+        var engine = new FixedStrategyNestingEngine("Strip");
+        // The job itself declares an unknown strategy; if FixedStrategyNestingEngine
+        // didn't override it, PlateNesterFactory would reject it with NotSupportedException.
+        var job = FiniteStockJobTests.Job(1, new NestJobOptions("Not A Real Strategy"));
+
+        var result = engine.Solve(job);
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+    }
+
+    [Fact]
+    public void PreservesJobMaxPlates()
+    {
+        var engine = new FixedStrategyNestingEngine("Default");
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(100, 100)), 6);
+        var stock = new NestPlateStock("sheet", new Size(220, 220), quantity: null, partSpacing: 2.0,
+            edgeSpacing: new Spacing(5.0, 5.0, 5.0, 5.0), quadrant: 1);
+        var job = new NestJob(new[] { part }, new[] { stock }, new NestJobOptions("Default", maxPlates: 1));
+
+        var result = engine.Solve(job);
+
+        Assert.Equal(NestJobStatus.Incomplete, result.Status);
+        Assert.Equal(NestJobStopReason.PlateLimitReached, result.StopReason);
+        Assert.Single(result.Plates);
+    }
+
+    [Fact]
+    public void RejectsNullOrWhitespaceStrategyAtConstruction()
+    {
+        Assert.Throws<ArgumentException>(() => new FixedStrategyNestingEngine(null));
+        Assert.Throws<ArgumentException>(() => new FixedStrategyNestingEngine("  "));
+    }
+}

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

@@ -41,6 +41,33 @@ public class NestJobValidationTests
         Assert.Equal(2, result.Plates[0].Placements.Count);
     }
 
+    [Fact]
+    public void SmallCornerOverlapIsRejected()
+    {
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(10, 10)), 2);
+        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, 9, 9, 0)));
+    }
+
+    [Theory]
+    [InlineData(10.0, 0.0)]
+    [InlineData(10.0, 10.0)]
+    public void BoundaryContactWithZeroSpacingIsAccepted(double x, double y)
+    {
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(10, 10)), 2);
+        var job = new NestJob(new[] { part }, new[] { new NestPlateStock("stock", new Size(20, 20), 1) });
+
+        var result = Solve(job,
+            new NestJobPlacement("part", 0, 0, 0, 0),
+            new NestJobPlacement("part", 1, x, y, 0));
+
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(2, Assert.Single(result.Plates).Placements.Count);
+    }
+
     [Fact]
     public void UnknownOrOverproducingCandidateFailsBeforeCommitWithoutChangingInput()
     {

OpenNest.Engine.Tests/Jobs/NestingEngineRegistryTests.cs

@@ -0,0 +1,49 @@
+using Xunit;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestingEngineRegistryTests
+{
+    [Fact]
+    public void BuiltInStrategiesAreRegistered()
+    {
+        var names = NestingEngineRegistry.AvailableEngines.Select(e => e.Name).ToList();
+
+        Assert.Contains("Default", names);
+        Assert.Contains("Strip", names);
+        Assert.Contains("Vertical Remnant", names);
+        Assert.Contains("Horizontal Remnant", names);
+    }
+
+    [Fact]
+    public void EachBuiltInFactoryProducesAWorkingEngine()
+    {
+        foreach (var info in NestingEngineRegistry.AvailableEngines)
+        {
+            var engine = info.Factory();
+            var result = engine.Solve(FiniteStockJobTests.Job(1));
+
+            Assert.Equal(NestJobStatus.Complete, result.Status);
+        }
+    }
+
+    [Fact]
+    public void DuplicateNameIsSkipped()
+    {
+        var before = NestingEngineRegistry.AvailableEngines.Count;
+
+        NestingEngineRegistry.Register("Default", "duplicate", () => new FixedStrategyNestingEngine("Default"));
+
+        Assert.Equal(before, NestingEngineRegistry.AvailableEngines.Count);
+    }
+
+    [Fact]
+    public void LoadPluginsAgainstMissingDirectoryIsANoOp()
+    {
+        var before = NestingEngineRegistry.AvailableEngines.Count;
+
+        NestingEngineRegistry.LoadPlugins(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()));
+
+        Assert.Equal(before, NestingEngineRegistry.AvailableEngines.Count);
+    }
+}

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

@@ -0,0 +1,212 @@
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class StockLadderTests
+{
+    private static NestJobPart Rectangle(string id, int quantity, double x = 4, double y = 4,
+        RotationPolicy? rotation = null) => new(id,
+        PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(x, y)), quantity,
+        rotation: rotation ?? RotationPolicy.Fixed(0));
+
+    [Fact]
+    public void MergesEquivalentDemandOntoLargerSheetAndReturnsFiniteStock()
+    {
+        var job = new NestJob(new[] { Rectangle("a", 5) }, new[]
+        {
+            new NestPlateStock("small", new Size(10, 10), 2),
+            new NestPlateStock("large", new Size(10, 18), 1)
+        });
+        var result = new StockLadderNestingEngine().Solve(job);
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal("large", Assert.Single(result.Plates).StockId);
+        Assert.Equal(5, Assert.Single(result.Fulfillment).Placed);
+        Assert.Equal(0, result.StockUsage.Single(s => s.StockId == "small").Used);
+        Assert.Equal(2, result.StockUsage.Single(s => s.StockId == "small").Remaining);
+        Verify(job, result);
+    }
+
+    [Fact]
+    public void FiniteStockAndPlateLimitDoNotOverproduce()
+    {
+        var parts = new[] { Rectangle("a", 9) };
+        var stock = new[] { new NestPlateStock("only", new Size(10, 10), 1) };
+        var job = new NestJob(parts, stock);
+        var result = new StockLadderNestingEngine().Solve(job);
+        Assert.Equal(NestJobStopReason.StockExhausted, result.StopReason);
+        Assert.Equal(4, result.Fulfillment[0].Placed);
+        Verify(job, result);
+        job = new NestJob(parts, new[] { new NestPlateStock("only", new Size(10, 10)) }, new NestJobOptions(maxPlates: 1));
+        result = new StockLadderNestingEngine().Solve(job);
+        Assert.Equal(NestJobStopReason.PlateLimitReached, result.StopReason);
+        Assert.Single(result.Plates);
+        Verify(job, result);
+    }
+
+    [Fact]
+    public void ConstrainedLargeSinglePrecedesSmallFillers()
+    {
+        var job = new NestJob(new[] { Rectangle("small", 12, 2, 2), Rectangle("large", 1, 12, 6) }, new[]
+        {
+            new NestPlateStock("small-sheet", new Size(10, 10)),
+            new NestPlateStock("large-sheet", new Size(10, 18))
+        });
+        var result = new StockLadderNestingEngine().Solve(job);
+        Assert.Equal("large", result.Plates[0].Placements[0].PartId);
+        Assert.Contains(result.Plates[0].Placements, p => p.PartId == "small");
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Verify(job, result);
+    }
+
+    [Theory]
+    [InlineData(1)] [InlineData(2)] [InlineData(3)] [InlineData(4)]
+    public void GeometrySpacingRotationsAndQuadrantsAreValidated(int quadrant)
+    {
+        var job = new NestJob(new[] { Rectangle("a", 6, 3, 5, RotationPolicy.Fixed(System.Math.PI / 2)) },
+            new[] { new NestPlateStock("sheet", new Size(12, 18), partSpacing: 0.25,
+                edgeSpacing: new Spacing { Left = 0.5, Right = 0.5, Top = 0.5, Bottom = 0.5 }, quadrant: quadrant) });
+        var result = new StockLadderNestingEngine().Solve(job);
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Verify(job, result);
+    }
+
+    [Fact]
+    public void ImpossibleDemandTerminatesWithoutUsingUnlimitedStock()
+    {
+        var job = new NestJob(new[] { Rectangle("a", 1, 100, 100) },
+            new[] { new NestPlateStock("sheet", new Size(10, 10)) });
+        var result = new StockLadderNestingEngine().Solve(job);
+        Assert.Equal(NestJobStopReason.NoPlacementFound, result.StopReason);
+        Assert.Empty(result.Plates);
+    }
+
+    [Fact]
+    public void CancellationBeforeAndDuringTrialNeverReturnsPartialSuccess()
+    {
+        var job = new NestJob(new[] { Rectangle("a", 1) }, new[] { new NestPlateStock("s", new Size(10, 10)) });
+        using var cts = new CancellationTokenSource();
+        var engine = new StockLadderNestingEngine(() => new CallbackNester(request =>
+        {
+            cts.Cancel();
+            return new PlateCandidate(Array.Empty<NestJobPlacement>());
+        }));
+        Assert.Throws<OperationCanceledException>(() => engine.Solve(job, token: cts.Token));
+        Assert.Throws<OperationCanceledException>(() => new StockLadderNestingEngine().Solve(job, token: cts.Token));
+    }
+
+    [Theory]
+    [InlineData(false)] [InlineData(true)]
+    public void RejectsOverlappingOrOverproducingNester(bool overproduce)
+    {
+        var job = new NestJob(new[] { Rectangle("a", 2) }, new[] { new NestPlateStock("s", new Size(10, 10)) });
+        var engine = new StockLadderNestingEngine(() => new CallbackNester(request =>
+            new PlateCandidate(overproduce
+                ? Enumerable.Repeat(new NestJobPlacement("a", 0, 0, 0, 0), 3)
+                : new[] { new NestJobPlacement("a", 0, 50, 0, 0) })));
+        Assert.Throws<InvalidOperationException>(() => engine.Solve(job));
+        // Direct full-demand overlap check, not masked by the single-part feasibility probe limit.
+        Assert.Throws<InvalidOperationException>(() => NestJobValidator.ValidateCandidate(
+            new PlateCandidate(new[] { new NestJobPlacement("a", 0, 0, 0, 0), new NestJobPlacement("a", 1, 1, 1, 0) }),
+            job.Plates[0], new Dictionary<string, int> { ["a"] = 2 }, job.Parts.ToDictionary(p => p.Id)));
+    }
+
+    [Fact]
+    public void SalvageCreditsOnlyOneUsableEdgeRectangleAndDefaultsToZero()
+    {
+        var part = Rectangle("a", 1);
+        var stock = new NestPlateStock("s", new Size(10, 10));
+        var sheet = new NestJobPlateResult(0, stock, new[] { new NestJobPlacement("a", 0, 0, 0, 0) });
+        NestJob Job(double rate, double min) => new(new[] { part }, new[] { stock },
+            new NestJobOptions(salvageRate: rate, minimumSalvageDimension: min));
+        Assert.Equal(100, StockLadderNestingEngine.EstimateNetArea(Job(0.5, 0), sheet));
+        Assert.Equal(100, StockLadderNestingEngine.EstimateNetArea(Job(0.5, 7), sheet));
+        Assert.Equal(70, StockLadderNestingEngine.EstimateNetArea(Job(0.5, 5), sheet), 6);
+        Assert.Throws<ArgumentOutOfRangeException>(() => new NestJobOptions(salvageRate: double.NaN));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new NestJobOptions(salvageRate: 1.1));
+    }
+
+    [Fact]
+    public void FailedRepackRetainsAllDemandAndFiniteStockAccounting()
+    {
+        var job = new NestJob(new[] { Rectangle("a", 5) }, new[]
+        {
+            new NestPlateStock("small", new Size(10, 10), 2),
+            new NestPlateStock("large", new Size(10, 18), 1)
+        });
+        var fullDemandLargeTrials = 0;
+        var engine = new StockLadderNestingEngine(() => new CallbackNester(request =>
+        {
+            var quantity = Assert.Single(request.Parts).Quantity;
+            if (request.Stock.Id == "large" && quantity == 5) fullDemandLargeTrials++;
+            // Deliberately fail to reproduce the fifth piece on the cheaper merged sheet.
+            return new PlateCandidate(Enumerable.Range(0, System.Math.Min(quantity, 4))
+                .Select(i => new NestJobPlacement("a", i, i % 2 * 4, i / 2 * 4, 0)));
+        }));
+        var result = engine.Solve(job);
+        Assert.True(fullDemandLargeTrials >= 2); // Construction AND equivalent-demand repack ran.
+        Assert.Equal(NestJobStatus.Complete, result.Status);
+        Assert.Equal(2, result.Plates.Count);
+        Assert.All(result.Plates, sheet => Assert.Equal("small", sheet.StockId));
+        Assert.Equal(5, Assert.Single(result.Fulfillment).Placed);
+        Assert.Equal(0, Assert.Single(result.Fulfillment).Unplaced);
+        Assert.Equal(0, result.StockUsage.Single(s => s.StockId == "large").Used);
+        Assert.Equal(1, result.StockUsage.Single(s => s.StockId == "large").Remaining);
+        Verify(job, result);
+    }
+
+    [Theory]
+    [InlineData(3.0, false)]
+    [InlineData(4.0001, true)]
+    public void OpenMarkMustRemainInsideClosedMaterial(double endX, bool reject)
+    {
+        var program = TestDrawingFactory.Rectangle(4, 4);
+        program.MoveTo(2, 2);
+        program.LineTo(endX, 2);
+        var part = new NestJobPart("exterior-mark", PartGeometrySnapshot.FromProgram(program), 1);
+        var job = new NestJob(new[] { part }, new[] { new NestPlateStock("s", new Size(10, 10)) });
+        if (reject)
+        {
+            var error = Assert.Throws<ArgumentException>(() => new StockLadderNestingEngine().Solve(job));
+            Assert.Contains("Open geometry leaves the closed material region", error.Message);
+        }
+        else
+        {
+            var result = new StockLadderNestingEngine().Solve(job);
+            Assert.Equal(NestJobStatus.Complete, result.Status);
+            Verify(job, result);
+        }
+    }
+
+    private static void Verify(NestJob job, NestJobResult result)
+    {
+        var parts = job.Parts.ToDictionary(p => p.Id);
+        var remaining = job.Parts.ToDictionary(p => p.Id, p => p.Quantity);
+        foreach (var sheet in result.Plates)
+        {
+            NestJobValidator.ValidateCandidate(new PlateCandidate(sheet.Placements), sheet.Stock, remaining, parts);
+            foreach (var pose in sheet.Placements) remaining[pose.PartId]--;
+        }
+        foreach (var part in job.Parts)
+        {
+            var poses = result.Plates.SelectMany(p => p.Placements).Where(p => p.PartId == part.Id).ToList();
+            Assert.Equal(Enumerable.Range(0, poses.Count), poses.Select(p => p.InstanceIndex));
+            var fulfillment = result.Fulfillment.Single(p => p.PartId == part.Id);
+            Assert.Equal(part.Quantity, fulfillment.Placed + fulfillment.Unplaced);
+            Assert.Equal(poses.Count, fulfillment.Placed);
+        }
+        foreach (var stock in job.Plates)
+        {
+            var count = result.Plates.Count(p => p.StockId == stock.Id);
+            var usage = result.StockUsage.Single(s => s.StockId == stock.Id);
+            Assert.Equal(count, usage.Used);
+            Assert.Equal(stock.Quantity - count, usage.Remaining);
+            Assert.True(stock.Quantity == null || count <= stock.Quantity);
+        }
+    }
+
+    private sealed class CallbackNester(Func<PlatePlacementRequest, PlateCandidate> callback) : IPlateNester
+    {
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default) => callback(request);
+    }
+}

OpenNest.Engine/Fill/IterativeShrinkFiller.cs

@@ -219,8 +219,10 @@ namespace OpenNest.Engine.Fill
             if (strips.Count <= 1)
                 return;
 
-            var gap = stripMin(strips[1]) - stripMax(strips[0]);
-
+            // Use the required clearance as the inter-strip gap, not a gap sampled from one
+            // original pair: actual placement gaps vary for irregular/mixed-size geometry, and
+            // replaying a larger sampled gap across every reordered pair can push the trailing
+            // strip past the original (already plate-fitted) footprint.
             strips.Sort((a, b) => sortMetric(a).CompareTo(sortMetric(b)));
 
             var pos = primaryEdge(parts[0].BoundingBox);
@@ -236,7 +238,7 @@ namespace OpenNest.Engine.Fill
                         part.Offset(offset);
                 }
 
-                pos = stripMax(s) + gap;
+                pos = stripMax(s) + spacing;
             }
 
             parts.Clear();

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

@@ -0,0 +1,29 @@
+using System;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>
+/// Adapts one fixed IPlateNester strategy to the whole-job INestingEngine contract, so it can compete
+/// as a full job solver alongside model-submitted engines. Delegates all multi-plate/size selection to
+/// NestJobRunner; only the placement strategy key is forced, overriding whatever the job itself declared.
+/// </summary>
+public sealed class FixedStrategyNestingEngine : INestingEngine
+{
+    private readonly string strategy;
+    private readonly NestJobRunner runner = new(PlateNesterFactory.Create);
+
+    public FixedStrategyNestingEngine(string strategy)
+    {
+        if (string.IsNullOrWhiteSpace(strategy))
+            throw new ArgumentException("Strategy cannot be null or whitespace.", nameof(strategy));
+        this.strategy = strategy;
+    }
+
+    public NestJobResult Solve(NestJob job, IProgress<NestJobProgress> progress = null, CancellationToken token = default)
+    {
+        ArgumentNullException.ThrowIfNull(job);
+        var forced = new NestJob(job.Parts, job.Plates, new NestJobOptions(strategy, job.Options.MaxPlates));
+        return runner.Solve(forced, progress, token);
+    }
+}

OpenNest.Engine/Jobs/NestJobOptions.cs

@@ -5,14 +5,27 @@ 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)
+    public NestJobOptions(string placementStrategy = "Default", int? maxPlates = null,
+        double salvageRate = 0, double minimumSalvageDimension = 0)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(placementStrategy);
         if (maxPlates <= 0) throw new ArgumentOutOfRangeException(nameof(maxPlates));
+        if (!double.IsFinite(salvageRate) || salvageRate < 0 || salvageRate > 1)
+            throw new ArgumentOutOfRangeException(nameof(salvageRate));
+        if (!double.IsFinite(minimumSalvageDimension) || minimumSalvageDimension < 0)
+            throw new ArgumentOutOfRangeException(nameof(minimumSalvageDimension));
         PlacementStrategy = placementStrategy;
         MaxPlates = maxPlates;
+        SalvageRate = salvageRate;
+        MinimumSalvageDimension = minimumSalvageDimension;
     }
 
+    /// <summary>Fraction of eligible edge-offcut area credited by StockLadder (0..1).</summary>
+    public double SalvageRate { get; }
+    /// <summary>Both offcut dimensions must meet this caller-supplied minimum in job units.
+    /// Zero disables credit; scraps and holes are never credited.</summary>
+    public double MinimumSalvageDimension { get; }
+
     public string PlacementStrategy { get; }
     /// <summary>Maximum physical sheets to commit, or null for no explicit cap.</summary>
     public int? MaxPlates { get; }

OpenNest.Engine/Jobs/NestJobPlacementValidator.cs

@@ -76,14 +76,131 @@ internal static class NestJobPlacementValidator
 
         var contours = ShapeBuilder.GetShapes(cutEntities);
         if (contours.Count == 0) throw new ArgumentException("Geometry must contain a closed contour.");
+        var closedEntities = new List<Entity>();
+        var marks = new List<Shape>();
         foreach (var contour in contours)
-            ValidateContour(contour);
+        {
+            if (contour.IsClosed())
+            {
+                ValidateContour(contour);
+                closedEntities.AddRange(contour.Entities);
+            }
+            else marks.Add(contour);
+        }
+        if (closedEntities.Count == 0)
+            throw new ArgumentException("Geometry must contain a closed outer contour.");
 
-        var profile = new ShapeProfile(cutEntities);
+        // ShapeProfile selects the outer profile, but does not validate containment and
+        // treats open chains as cutouts. Only validated closed contours may define material.
+        var profile = new ShapeProfile(closedEntities);
+        foreach (var cutout in profile.Cutouts)
+            ValidateInternalChain(cutout, profile.Perimeter, new List<Shape>());
+        foreach (var mark in marks)
+            ValidateMark(mark, profile.Perimeter, profile.Cutouts);
         profile.NormalizeWinding();
         return new ShapeTopology(profile.Perimeter, profile.Cutouts);
     }
 
+    private static void ValidateMark(Shape mark, Shape perimeter, List<Shape> holes)
+    {
+        const double chordTolerance = 0.00001;
+        var boundaries = new List<Shape> { perimeter };
+        boundaries.AddRange(holes);
+        var polygons = boundaries.ConvertAll(s => s.ToPolygonWithTolerance(chordTolerance));
+        foreach (var entity in mark.Entities)
+        {
+            if (entity.Length <= Epsilon || entity is not (Line or Arc))
+                throw new ArgumentException("Unsupported or degenerate internal mark.");
+            var parameters = new List<double> { 0, 1 };
+            foreach (var boundary in boundaries)
+            {
+                entity.Intersects(boundary, out var intersections);
+                foreach (var point in intersections)
+                    AddParameter(point);
+                // Include endpoints of coincident edges (parallel intersections may be empty).
+                foreach (var point in boundary.Entities.CollectPoints())
+                    if (entity.ClosestPointTo(point).DistanceTo(point) <= Epsilon)
+                        AddParameter(point);
+            }
+            parameters.Sort();
+            for (var index = 0; index < parameters.Count; index++)
+            {
+                Check(PointAt(parameters[index]));
+                if (index > 0) Check(PointAt((parameters[index - 1] + parameters[index]) / 2));
+            }
+
+            void AddParameter(Vector point)
+            {
+                if (!point.IsValid()) throw new ArgumentException("Indeterminate mark intersection.");
+                var value = entity is Line line
+                    ? line.StartPoint.DistanceTo(point) / line.Length
+                    : Angle.NormalizeRad(((Arc)entity).IsReversed
+                        ? ((Arc)entity).StartAngle - ((Arc)entity).Center.AngleTo(point)
+                        : ((Arc)entity).Center.AngleTo(point) - ((Arc)entity).StartAngle) / ((Arc)entity).SweepAngle();
+                if (value >= 0 && value <= 1) parameters.Add(value);
+            }
+            Vector PointAt(double value)
+            {
+                if (entity is Line line) return line.StartPoint + (line.EndPoint - line.StartPoint) * value;
+                var arc = (Arc)entity;
+                var angle = arc.StartAngle + (arc.IsReversed ? -1 : 1) * arc.SweepAngle() * value;
+                return arc.Center + new Vector(System.Math.Cos(angle), System.Math.Sin(angle)) * arc.Radius;
+            }
+            void Check(Vector point)
+            {
+                for (var index = 0; index < boundaries.Count; index++)
+                {
+                    // Exact analytic boundary contact is allowed; near-boundary uncertainty is not.
+                    var onBoundary = false;
+                    foreach (var edge in boundaries[index].Entities)
+                        if (edge.ClosestPointTo(point).DistanceTo(point) <= Epsilon) onBoundary = true;
+                    if (onBoundary) continue;
+                    foreach (var edge in polygons[index].ToLines())
+                        if (edge.ClosestPointTo(point).DistanceTo(point) <= 2 * chordTolerance)
+                            throw new ArgumentException("Internal mark is too close to a material boundary.");
+                    var inside = StrictlyInside(polygons[index], point);
+                    if (index == 0 ? !inside : inside)
+                        throw new ArgumentException("Open geometry leaves the closed material region.");
+                }
+            }
+        }
+    }
+
+    private static void ValidateInternalChain(Shape chain, Shape perimeter, List<Shape> holes)
+    {
+        // A connected analytic entity cannot leave material without crossing its boundary.
+        // Reject contact too: conservative, rather than guessing at tangent/collinear cuts.
+        // The witness point is farther than the polygonization error from every boundary.
+        const double chordTolerance = 0.00001;
+        var boundaries = new List<Shape> { perimeter };
+        boundaries.AddRange(holes);
+        var polygons = boundaries.ConvertAll(s => s.ToPolygonWithTolerance(chordTolerance));
+        foreach (var entity in chain.Entities)
+        {
+            if (entity.Length <= Epsilon)
+                throw new ArgumentException("Geometry contains a zero-length internal edge.");
+            var point = entity switch
+            {
+                Line line => line.StartPoint,
+                Arc arc => arc.StartPoint(),
+                Circle circle => circle.Center.Offset(circle.Radius, 0),
+                _ => throw new ArgumentException("Unsupported internal geometry.")
+            };
+            if (!StrictlyInside(polygons[0], point))
+                throw new ArgumentException("Open or disconnected geometry lies outside the closed perimeter.");
+            for (var index = 0; index < boundaries.Count; index++)
+            {
+                if (index > 0 && polygons[index].ContainsPoint(point))
+                    throw new ArgumentException("Internal geometry lies in a cutout.");
+                foreach (var edge in polygons[index].ToLines())
+                    if (edge.ClosestPointTo(point).DistanceTo(point) <= 2 * chordTolerance)
+                        throw new ArgumentException("Internal geometry is too close to a material boundary.");
+                if (entity.Intersects(boundaries[index]))
+                    throw new ArgumentException("Internal geometry crosses or touches a material boundary.");
+            }
+        }
+    }
+
     private static void ValidateContour(Shape contour)
     {
         if (!contour.IsClosed())
@@ -145,65 +262,10 @@ internal static class NestJobPlacementValidator
             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;
+        // Collision checks this by clipping triangulated polygons and rejecting zero-area
+        // slivers, so it catches containment and small corner intersections that a witness
+        // probe can miss, while contact stays legal; cutouts are subtracted from both sides.
+        return Collision.HasOverlap(leftPoly, rightPoly, ToPolygons(left.Cutouts), ToPolygons(right.Cutouts));
     }
 
     /// <summary>
@@ -243,14 +305,6 @@ internal static class NestJobPlacementValidator
     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;

OpenNest.Engine/Jobs/NestJobValidator.cs

@@ -31,7 +31,7 @@ public static class NestJobValidator
             }
             catch (ArgumentException exception)
             {
-                throw new ArgumentException($"Geometry must contain usable closed edges: {part.Id}.", nameof(job), exception);
+                throw new ArgumentException($"Geometry must contain usable closed edges: {part.Id}. {exception.Message}", nameof(job), exception);
             }
         }
     }

OpenNest.Engine/Jobs/NestingEngineInfo.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace OpenNest;
+
+/// <summary>Display metadata plus a fresh-instance factory for one registered whole-job engine.</summary>
+public class NestingEngineInfo
+{
+    public NestingEngineInfo(string name, string description, Func<INestingEngine> factory)
+    {
+        Name = name;
+        Description = description;
+        Factory = factory;
+    }
+
+    public string Name { get; }
+    public string Description { get; }
+    public Func<INestingEngine> Factory { get; }
+}

OpenNest.Engine/Jobs/NestingEngineRegistry.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace OpenNest;
+
+/// <summary>
+/// Registry of whole-job INestingEngine implementations, parallel to NestEngineRegistry (which is for
+/// the legacy single-plate NestEngineBase). The four production strategies are exposed here through
+/// FixedStrategyNestingEngine so they compete on equal footing with model-submitted engines. Unlike
+/// NestEngineRegistry, this has no ActiveEngineName/global-selection concept — callers choose an engine
+/// explicitly from AvailableEngines.
+/// </summary>
+public static class NestingEngineRegistry
+{
+    private static readonly List<NestingEngineInfo> engines = new();
+
+    static NestingEngineRegistry()
+    {
+        Register("StockLadder", "Caller-stock constrained-first fill and equivalent-demand area repacking",
+            () => new StockLadderNestingEngine());
+
+        Register("Default", "Multi-phase nesting (Linear, Pairs, RectBestFit, Remainder)",
+            () => new FixedStrategyNestingEngine("Default"));
+
+        Register("Strip", "Strip-based nesting for mixed-drawing layouts",
+            () => new FixedStrategyNestingEngine("Strip"));
+
+        Register("Vertical Remnant", "Optimizes for largest right-side vertical drop",
+            () => new FixedStrategyNestingEngine("Vertical Remnant"));
+
+        Register("Horizontal Remnant", "Optimizes for largest top-side horizontal drop",
+            () => new FixedStrategyNestingEngine("Horizontal Remnant"));
+    }
+
+    public static IReadOnlyList<NestingEngineInfo> AvailableEngines => engines;
+
+    public static void Register(string name, string description, Func<INestingEngine> factory)
+    {
+        if (engines.Any(e => e.Name.Equals(name, StringComparison.OrdinalIgnoreCase)))
+        {
+            Debug.WriteLine($"[NestingEngineRegistry] Duplicate engine '{name}' skipped");
+            return;
+        }
+
+        engines.Add(new NestingEngineInfo(name, description, factory));
+    }
+
+    /// <summary>Scans *.dll in directory for non-abstract INestingEngine types with a public
+    /// parameterless constructor, registering each under its CLR type name. Mirrors
+    /// NestEngineRegistry.LoadPlugins's per-assembly/per-type isolation: one bad plugin never
+    /// prevents the rest from loading.</summary>
+    public static void LoadPlugins(string directory)
+    {
+        if (!Directory.Exists(directory))
+            return;
+
+        foreach (var dll in Directory.GetFiles(directory, "*.dll"))
+        {
+            try
+            {
+                var assembly = Assembly.LoadFrom(dll);
+
+                foreach (var type in assembly.GetTypes())
+                {
+                    if (type.IsAbstract || !typeof(INestingEngine).IsAssignableFrom(type))
+                        continue;
+
+                    var ctor = type.GetConstructor(Type.EmptyTypes);
+
+                    if (ctor == null)
+                    {
+                        Debug.WriteLine($"[NestingEngineRegistry] Skipping {type.Name}: no parameterless constructor");
+                        continue;
+                    }
+
+                    try
+                    {
+                        Register(type.Name, string.Empty, () => (INestingEngine)ctor.Invoke(null));
+                        Debug.WriteLine($"[NestingEngineRegistry] Loaded plugin engine: {type.Name}");
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug.WriteLine($"[NestingEngineRegistry] Failed to register {type.Name}: {ex.Message}");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"[NestingEngineRegistry] Failed to load assembly {Path.GetFileName(dll)}: {ex.Message}");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using OpenNest.Engine.Fill;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+/// <summary>Constrained-order linear fills in conservative rectangular free regions.
+/// Regions are only search hints; every accepted pose passes the job geometry validator.</summary>
+internal sealed class OrderedPlateNester : IPlateNester
+{
+    private readonly Dictionary<string, Drawing> drawings = new(StringComparer.Ordinal);
+
+    public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default)
+    {
+        var work = DrawingJobMapper.CreatePlate(request.Stock).WorkArea();
+        var poses = new List<NestJobPlacement>();
+        var obstacles = new List<Box>();
+        var requirements = request.Parts.ToDictionary(p => p.Id);
+        var demand = request.Parts.ToDictionary(p => p.Id, p => p.Quantity);
+        foreach (var requirement in request.Parts)
+        {
+            token.ThrowIfCancellationRequested();
+            if (!drawings.TryGetValue(requirement.Id, out var drawing))
+                drawings.Add(requirement.Id, drawing = DrawingJobMapper.CreateDrawing(requirement));
+            var left = requirement.Quantity;
+            while (left > 0)
+            {
+                var regions = new RemnantFinder(work, obstacles).FindRemnants();
+                List<Part> best = null;
+                foreach (var region in regions)
+                {
+                    foreach (var angle in Angles(requirement.Rotation))
+                    {
+                        token.ThrowIfCancellationRequested();
+                        // FillLinear uses actual line/arc geometry for copy distances.
+                        var parts = new FillLinear(region, request.Stock.PartSpacing)
+                            .Fill(drawing, angle, NestDirection.Horizontal).Take(left).ToList();
+                        if (parts.Count == 0 || (best != null && parts.Count <= best.Count)) continue;
+                        var trial = poses.Concat(parts.Select(p => new NestJobPlacement(requirement.Id, 0,
+                            p.Location.X, p.Location.Y, p.Rotation))).ToList();
+                        try
+                        {
+                            NestJobValidator.ValidateCandidate(new PlateCandidate(trial), request.Stock, demand, requirements);
+                            best = parts;
+                        }
+                        catch (InvalidOperationException)
+                        {
+                            // Geometry kernels are proposal generators, never the acceptance gate.
+                        }
+                        if (best?.Count == left) break;
+                    }
+                    if (best?.Count == left) break;
+                }
+                if (best == null) break;
+                foreach (var part in best)
+                {
+                    poses.Add(new NestJobPlacement(requirement.Id, 0, part.Location.X, part.Location.Y, part.Rotation));
+                    obstacles.Add(part.BoundingBox.Offset(request.Stock.PartSpacing));
+                }
+                left -= best.Count;
+            }
+        }
+        token.ThrowIfCancellationRequested();
+        return new PlateCandidate(poses);
+    }
+
+    private static IEnumerable<double> Angles(RotationPolicy policy)
+    {
+        if (policy.Kind == RotationPolicyKind.Fixed)
+        {
+            yield return policy.Start;
+            yield break;
+        }
+        // A bounded deterministic search, not a proof that an unplaced part cannot fit.
+        if (policy.Kind == RotationPolicyKind.Automatic)
+        {
+            yield return 0;
+            yield return System.Math.PI / 2;
+            yield return System.Math.PI;
+            yield return 3 * System.Math.PI / 2;
+            for (var degrees = 5; degrees < 180; degrees += 5)
+                if (degrees != 90) yield return degrees * System.Math.PI / 180;
+            yield break;
+        }
+        for (var index = 0L; ; index++)
+        {
+            var angle = policy.Start + index * policy.Step;
+            if (angle > policy.End + 1e-9) yield break;
+            yield return angle;
+        }
+    }
+}

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

@@ -2,9 +2,10 @@ using System;
 namespace OpenNest;
 
 /// <summary>
-/// Instance-scoped strategy resolution for the whole-job runner. The built-in strategies map
-/// to private engine factories; the process-global NestEngineRegistry (including plugin
-/// registrations and ActiveEngineName) is neither read nor modified. Unknown keys reject.
+/// 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
 {
@@ -13,8 +14,8 @@ public static class PlateNesterFactory
         ArgumentNullException.ThrowIfNull(strategy);
         return strategy switch
         {
-            "Default" => new LegacyPlateNesterAdapter(plate => new DefaultNestEngine(plate)),
-            "Strip" => new LegacyPlateNesterAdapter(plate => new StripNestEngine(plate)),
+            "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/StockLadderNestingEngine.cs

@@ -0,0 +1,195 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+namespace OpenNest;
+
+/// <summary>
+/// Caller-stock-only allocation followed by bounded adjacent-sheet repacking. All replacements
+/// must reproduce exactly the removed demand and reduce net sheet area; inventory is transactional.
+/// This is a deterministic heuristic, not an optimality or geometric impossibility proof.
+/// </summary>
+public sealed class StockLadderNestingEngine : INestingEngine
+{
+    private readonly Func<IPlateNester> factory;
+    public StockLadderNestingEngine() : this(() => new OrderedPlateNester()) { }
+    public StockLadderNestingEngine(Func<IPlateNester> factory) =>
+        this.factory = factory ?? throw new ArgumentNullException(nameof(factory));
+
+    public NestJobResult Solve(NestJob job, IProgress<NestJobProgress> progress = null,
+        CancellationToken token = default)
+    {
+        ArgumentNullException.ThrowIfNull(job);
+        token.ThrowIfCancellationRequested();
+        NestJobValidator.Validate(job);
+        var nester = factory() ?? throw new InvalidOperationException("Null plate nester.");
+        var parts = job.Parts.ToDictionary(p => p.Id, StringComparer.Ordinal);
+        var remaining = job.Parts.ToDictionary(p => p.Id, p => p.Quantity, StringComparer.Ordinal);
+        var used = job.Plates.ToDictionary(s => s.Id, _ => 0, StringComparer.Ordinal);
+        var areas = job.Parts.ToDictionary(p => p.Id, p => DrawingJobMapper.CreateDrawing(p).Area);
+        var sheets = new List<NestJobPlateResult>();
+        var feasible = job.Parts.ToDictionary(p => p.Id, _ => new HashSet<string>());
+
+        // Probe actual validated single-part placements, not bounding-box fit assertions.
+        foreach (var part in job.Parts)
+            foreach (var stock in job.Plates.Where(s => s.Quantity != 0))
+            {
+                var probe = Trial(stock, new[] { WithQuantity(part, 1) });
+                if (probe.Placements.Count != 0) feasible[part.Id].Add(stock.Id);
+            }
+        var ordered = job.Parts.OrderBy(p => p.Priority)
+            .ThenBy(p => feasible[p.Id].Count).ThenByDescending(p => areas[p.Id]).ToList();
+        var reason = NestJobStopReason.Completed;
+        while (remaining.Values.Any(n => n > 0))
+        {
+            token.ThrowIfCancellationRequested();
+            if (job.Options.MaxPlates <= sheets.Count)
+            {
+                if (Consolidate()) continue;
+                reason = NestJobStopReason.PlateLimitReached;
+                break;
+            }
+            var available = job.Plates.Where(s => s.Quantity == null || used[s.Id] < s.Quantity).ToList();
+            if (available.Count == 0)
+            {
+                if (Consolidate()) continue;
+                reason = NestJobStopReason.StockExhausted;
+                break;
+            }
+            var anchor = ordered.FirstOrDefault(p => remaining[p.Id] > 0 &&
+                available.Any(s => feasible[p.Id].Contains(s.Id)));
+            if (anchor == null)
+            {
+                reason = NestJobStopReason.NoPlacementFound;
+                break;
+            }
+            NestJobPlateResult winner = null;
+            var score = double.PositiveInfinity;
+            foreach (var stock in available.Where(s => feasible[anchor.Id].Contains(s.Id)))
+            {
+                // Pin the constrained anchor before fillers, including quantity-one requirements.
+                var requests = new[] { anchor }.Concat(ordered.Where(p => p.Id != anchor.Id))
+                    .Where(p => remaining[p.Id] > 0).Select(p => WithQuantity(p, remaining[p.Id]));
+                var candidate = Trial(stock, requests);
+                if (!candidate.Placements.Any(p => p.PartId == anchor.Id)) continue;
+                var sheet = new NestJobPlateResult(sheets.Count, stock, candidate.Placements);
+                // Initial construction only: material area, never raw part counts. Repacking below
+                // compares EXACTLY equivalent demand, and never replaces a sheet by a partial fill.
+                var value = EstimateNetArea(job, sheet) / candidate.Placements.Sum(p => areas[p.PartId]);
+                if (value < score - 1e-9)
+                {
+                    winner = sheet;
+                    score = value;
+                }
+            }
+            if (winner == null)
+            {
+                reason = NestJobStopReason.NoPlacementFound;
+                break;
+            }
+            sheets.Add(winner);
+            used[winner.StockId]++;
+            foreach (var pose in winner.Placements) remaining[pose.PartId]--;
+            progress?.Report(new NestJobProgress(NestJobStage.PlateCommitted, winner.StockId,
+                sheets.Count - 1, sheets.Count, sheets.Sum(s => s.Placements.Count)));
+        }
+        Consolidate();
+        token.ThrowIfCancellationRequested();
+        var placed = job.Parts.ToDictionary(p => p.Id, _ => 0);
+        var final = sheets.Select((sheet, index) => new NestJobPlateResult(index, sheet.Stock,
+            sheet.Placements.Select(p => p with { InstanceIndex = placed[p.PartId]++ }).ToList())).ToList();
+        return new NestJobResult(reason == NestJobStopReason.Completed ? NestJobStatus.Complete : NestJobStatus.Incomplete,
+            reason, final, job.Parts.Select(p => new PartFulfillment(p.Id, p.Quantity, placed[p.Id], remaining[p.Id])),
+            job.Plates.Select(s => new StockUsage(s.Id, used[s.Id], s.Quantity - used[s.Id])));
+
+        PlateCandidate Trial(NestPlateStock stock, IEnumerable<NestJobPart> requirements)
+        {
+            token.ThrowIfCancellationRequested();
+            var request = new PlatePlacementRequest(stock, requirements);
+            progress?.Report(new NestJobProgress(NestJobStage.EvaluatingCandidate, stock.Id,
+                sheets.Count, sheets.Count, sheets.Sum(s => s.Placements.Count)));
+            var candidate = nester.Place(request, null, token);
+            token.ThrowIfCancellationRequested();
+            NestJobValidator.ValidateCandidate(candidate, stock, request.Parts.ToDictionary(p => p.Id, p => p.Quantity), parts);
+            return candidate;
+        }
+
+        bool Consolidate()
+        {
+            var changed = false;
+            // Single downgrade and adjacent pair merge only: bounded local search, no combinatorial tree.
+            for (var index = 0; index < sheets.Count; index++)
+                for (var count = System.Math.Min(2, sheets.Count - index); count >= 1; count--)
+                {
+                    var old = sheets.Skip(index).Take(count).ToList();
+                    var demand = old.SelectMany(s => s.Placements).GroupBy(p => p.PartId)
+                        .ToDictionary(g => g.Key, g => g.Count());
+                    var baseline = old.Sum(s => EstimateNetArea(job, s));
+                    NestJobPlateResult replacement = null;
+                    foreach (var stock in job.Plates)
+                    {
+                        token.ThrowIfCancellationRequested();
+                        var returned = old.Count(s => s.StockId == stock.Id);
+                        if (stock.Quantity is int limit && used[stock.Id] - returned >= limit) continue;
+                        // Even the maximum possible salvage credit cannot beat the incumbent.
+                        var lowerBound = stock.Size.Width * stock.Size.Length * (1 - job.Options.SalvageRate);
+                        if (lowerBound >= baseline - 1e-9) continue;
+                        if (demand.Keys.Any(id => !feasible[id].Contains(stock.Id))) continue;
+                        var candidate = Trial(stock, ordered.Where(p => demand.ContainsKey(p.Id))
+                            .Select(p => WithQuantity(p, demand[p.Id])));
+                        var actual = candidate.Placements.GroupBy(p => p.PartId).ToDictionary(g => g.Key, g => g.Count());
+                        if (demand.Any(kv => !actual.TryGetValue(kv.Key, out var n) || n != kv.Value)) continue;
+                        var trial = new NestJobPlateResult(index, stock, candidate.Placements);
+                        var cost = EstimateNetArea(job, trial);
+                        if (cost >= baseline - 1e-9) continue;
+                        baseline = cost;
+                        replacement = trial;
+                    }
+                    if (replacement == null) continue;
+                    // No accounting changes until the entire equivalent-demand candidate is valid.
+                    foreach (var sheet in old) used[sheet.StockId]--;
+                    used[replacement.StockId]++;
+                    sheets.RemoveRange(index, count);
+                    sheets.Insert(index, replacement);
+                    changed = true;
+                }
+            return changed;
+        }
+    }
+
+    private static NestJobPart WithQuantity(NestJobPart part, int quantity) =>
+        new(part.Id, part.Geometry, quantity, part.Priority, part.Rotation);
+
+    /// <summary>Full physical sheet area minus a conservative offcut estimate. Credits only ONE
+    /// empty full-span edge rectangle outside every placed bounding box plus part clearance, within
+    /// the usable work area, and meeting the caller's minimum in both dimensions. Not a certified
+    /// remnant: no cut-off toolpath, kerf, handling, or future-demand valuation is modelled.</summary>
+    public static double EstimateNetArea(NestJob job, NestJobPlateResult sheet)
+    {
+        var area = sheet.Stock.Size.Width * sheet.Stock.Size.Length;
+        var minimum = job.Options.MinimumSalvageDimension;
+        if (job.Options.SalvageRate == 0 || minimum <= 0 || sheet.Placements.Count == 0) return area;
+        var work = DrawingJobMapper.CreatePlate(sheet.Stock).WorkArea();
+        var parts = job.Parts.ToDictionary(p => p.Id);
+        var boxes = sheet.Placements.Select(p =>
+        {
+            var part = new Part(DrawingJobMapper.CreateDrawing(parts[p.PartId]));
+            part.Rotate(p.Rotation);
+            part.Location = new OpenNest.Geometry.Vector(p.X, p.Y);
+            part.UpdateBounds();
+            return part.BoundingBox;
+        }).ToList();
+        var gap = sheet.Stock.PartSpacing;
+        var candidates = new[]
+        {
+            (work.Length, boxes.Min(b => b.Bottom) - work.Bottom - gap),
+            (work.Length, work.Top - boxes.Max(b => b.Top) - gap),
+            (boxes.Min(b => b.Left) - work.Left - gap, work.Width),
+            (work.Right - boxes.Max(b => b.Right) - gap, work.Width)
+        };
+        var salvage = candidates.Where(c => c.Item1 >= minimum && c.Item2 >= minimum)
+            .Select(c => c.Item1 * c.Item2).DefaultIfEmpty(0).Max();
+        return area - job.Options.SalvageRate * salvage;
+    }
+}

OpenNest.Engine/OpenNest.Engine.csproj

@@ -6,6 +6,7 @@
   </PropertyGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="OpenNest.Tests" />
+    <InternalsVisibleTo Include="OpenNest.Engine.Tests" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />

OpenNest.sln

@@ -34,6 +34,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenNest.Posts.GravographIS
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenNest.Data", "OpenNest.Data\OpenNest.Data.csproj", "{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenNest.Benchmark", "OpenNest.Benchmark\OpenNest.Benchmark.csproj", "{ACD8F725-829A-48A8-AA59-61DD90DE06CA}"
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenNest.Engine.Tests", "OpenNest.Engine.Tests\OpenNest.Engine.Tests.csproj", "{F2EF39E0-1A95-4C32-B50B-3D71EC72F692}"
 EndProject
 Global
@@ -178,18 +179,6 @@ Global
 		{FB1B2EB2-9D80-4499-BA93-B4E2F295A532}.Release|x64.Build.0 = Release|Any CPU
 		{FB1B2EB2-9D80-4499-BA93-B4E2F295A532}.Release|x86.ActiveCfg = Release|Any CPU
 		{FB1B2EB2-9D80-4499-BA93-B4E2F295A532}.Release|x86.Build.0 = Release|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x64.Build.0 = Debug|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x86.Build.0 = Debug|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x64.ActiveCfg = Release|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x64.Build.0 = Release|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x86.ActiveCfg = Release|Any CPU
-		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x86.Build.0 = Release|Any CPU
 		{3A6B8E7E-9B5F-4D2C-8AE3-2C9F5E3D1A40}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3A6B8E7E-9B5F-4D2C-8AE3-2C9F5E3D1A40}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3A6B8E7E-9B5F-4D2C-8AE3-2C9F5E3D1A40}.Debug|x64.ActiveCfg = Debug|Any CPU
@@ -202,6 +191,30 @@ Global
 		{3A6B8E7E-9B5F-4D2C-8AE3-2C9F5E3D1A40}.Release|x64.Build.0 = Release|Any CPU
 		{3A6B8E7E-9B5F-4D2C-8AE3-2C9F5E3D1A40}.Release|x86.ActiveCfg = Release|Any CPU
 		{3A6B8E7E-9B5F-4D2C-8AE3-2C9F5E3D1A40}.Release|x86.Build.0 = Release|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x64.Build.0 = Debug|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Debug|x86.Build.0 = Debug|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x64.ActiveCfg = Release|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x64.Build.0 = Release|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x86.ActiveCfg = Release|Any CPU
+		{A0B4B48E-1DF0-4DD3-B42C-B9B7779EA8B0}.Release|x86.Build.0 = Release|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Debug|x64.Build.0 = Debug|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Debug|x86.Build.0 = Debug|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Release|x64.ActiveCfg = Release|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Release|x64.Build.0 = Release|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Release|x86.ActiveCfg = Release|Any CPU
+		{ACD8F725-829A-48A8-AA59-61DD90DE06CA}.Release|x86.Build.0 = Release|Any CPU
 		{F2EF39E0-1A95-4C32-B50B-3D71EC72F692}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{F2EF39E0-1A95-4C32-B50B-3D71EC72F692}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F2EF39E0-1A95-4C32-B50B-3D71EC72F692}.Debug|x64.ActiveCfg = Debug|Any CPU

README.md

@@ -72,11 +72,11 @@ dotnet test OpenNest.Engine.Tests/OpenNest.Engine.Tests.csproj
 
 `OpenNest.Engine.Tests` targets `net8.0` and runs on Linux, macOS, and Windows without the desktop project or local DXF fixtures. The existing `OpenNest.Tests` suite still requires Windows.
 
-The new whole-job contracts in `OpenNest.Engine/Jobs` (`namespace OpenNest`) use owned immutable geometry/settings, explicit part IDs and positive demand, finite or unlimited stock (`null` means unlimited; zero means unavailable), and result ID/pose values rather than mutable desktop models. Rotation is in radians about the geometry origin, followed by translation into the plate quadrant frame. Strategy factories belong to each runner, not the global registry.
+The new whole-job contracts in `OpenNest.Engine/Jobs` (`namespace OpenNest`) use owned immutable geometry/settings, explicit part IDs and positive demand, finite or unlimited stock (`null` means unlimited; zero means unavailable), and result ID/pose values rather than mutable desktop models. Callers own their inputs: the job copies everything at entry and the result leaks no mutable `Drawing`, `Plate`, or `NestItem`. One job is one material/thickness/unit system — no cross-material pooling. Rotation is in radians about the geometry origin, followed by translation into the plate quadrant frame. Strategy factories belong to each runner, not the global registry. In the public API, the legacy `SheetSize` request field is the unlimited-stock fallback only when `Plates` is null; an explicit empty `Plates` list means no available stock.
 
-**Current scope (minimum runnable slice, not release-ready):** `NestJobRunner.Solve` allocates one stock entry across multiple physical sheets, respecting finite inventory (`null` is unlimited), positive remaining demand, and `MaxPlates`. Empty parts complete without consuming stock; empty/unavailable stock returns `Incomplete/StockExhausted`. A zero-placement candidate stops with `NoPlacementFound` and consumes no sheet. Nonempty jobs with multiple stock entries explicitly throw `NotSupportedException`; mixed-stock selection and optional optimizations are not implemented.
+`NestJobRunner.Solve` allocates a job across physical sheets from the full stock inventory: every available stock entry is trialled independently each iteration, and only the winning candidate consumes a sheet or reduces demand. Selection is a documented deterministic greedy policy — lexicographic placed-count vector by ascending part priority, then lower consumed sheet area, then smaller placement envelope, then original stock input order (see `NestJobCandidateComparer`). It is a tie policy, not a guarantee of global-minimum material or plate count. Finite stock is never exceeded; `MaxPlates` caps sheet count; empty parts complete without consuming stock; empty or fully exhausted stock returns `Incomplete/StockExhausted`; a zero-placement candidate stops with `NoPlacementFound` and consumes no sheet.
 
-`DrawingJobMapper` snapshots caller drawings/items under explicit requirement IDs. `LegacyPlateNesterAdapter` creates fresh private legacy drawings, items, and plates for each trial and maps returned drawings **by reference**, never by name. Mutable legacy quantities never drive the fulfillment ledger. `PlateNesterFactory` resolves the built-in strategies (`Default`, `Strip`, `Vertical Remnant`, `Horizontal Remnant`) to private engine factories; it neither reads nor changes the process-global `NestEngineRegistry`, and unknown keys reject. Quantity deduction in the engine paths the runner reaches (base-class fill/pack, strip deduction, remnant-fill ledger, shrink-leftover counting) is keyed by drawing reference, not display name, so same-name drawings and repeated requirements stay independent. `NestResultMaterializer` returns a detached domain nest and `DrawingsByPartId` identity map. Each output plate represents one physical sheet (`Quantity = 1`), and each placement is attached exactly once so domain quantity events do not double count.
+`DrawingJobMapper` snapshots caller drawings/items under explicit requirement IDs. `LegacyPlateNesterAdapter` creates fresh private legacy drawings, items, and plates for each trial and maps returned drawings **by reference**, never by name. Mutable legacy quantities never drive the fulfillment ledger. `PlateNesterFactory` resolves the built-in strategy names (`Default`, `Strip`, `Vertical Remnant`, `Horizontal Remnant`) to instance-scoped placement strategies; it neither reads nor changes the process-global `NestEngineRegistry`, and unknown keys reject. Quantity deduction in the engine paths the runner reaches (base-class fill/pack, strip deduction, remnant-fill ledger, shrink-leftover counting) is keyed by drawing reference, not display name, so same-name drawings and repeated requirements stay independent. `NestResultMaterializer` returns a detached domain nest and `DrawingsByPartId` identity map. Each output plate represents one physical sheet (`Quantity = 1`), and each placement is attached exactly once so domain quantity events do not double count.
 
 ```csharp
 var job = new NestJob(
@@ -88,7 +88,11 @@ var domainResult = NestResultMaterializer.Materialize(job, result);
 // domainResult.Nest and domainResult.DrawingsByPartId are detached from caller objects.
 ```
 
-**Unfinished safety boundary:** basic validation rejects invalid dimensions/settings, nonfinite geometry, unknown candidate IDs, nonfinite poses, and overproduction. Cancellation throws initially and immediately after the engine returns; no partial result is returned. Full contour validity, plate containment, allowed-rotation enforcement, inter-part overlap/clearance validation, and broader cancellation coverage remain task 5 work. A committed candidate is therefore **not yet certified safe for cutting**, even if the legacy engine reports success. Geometry snapshots preserve flat CNC rapid/line/arc programs, including origin and hole contours, without approximation; other instructions are explicitly rejected. Existing desktop, API, CLI, and MCP nesting paths are unchanged.
+**Safety gate:** before the runner commits any candidate, `NestJobPlacementValidator` re-checks it against the immutable job geometry: closed usable contours, finite poses, the requirement's rotation policy (automatic / fixed / bounded sweep with step), containment inside the per-quadrant usable work area, hole-aware material overlap, and required part spacing (touching is allowed at zero spacing, rejected at positive spacing). Malformed engine output fails explicitly without consuming stock or demand. Cancellation throws `OperationCanceledException` before each trial and immediately after each engine return; no half-committed state is returned. An `Incomplete` result means the heuristic stopped, not that the geometry is impossible — the stop reason says why. Geometry snapshots preserve flat CNC rapid/line/arc programs, including origin and hole contours, without approximation; other instructions are explicitly rejected.
+
+**Placement strategies:** `Default` and `Strip` are migrated built-ins (`OpenNest.Engine/Jobs/Placement/DefaultPlateNester.cs`, `StripPlateNester.cs`) that reuse the engine geometry while keeping demand read-only; the remnant strategies still run through `LegacyPlateNesterAdapter` during rollout. A runnable end-to-end example — multiple requirements, mixed finite/unlimited stock, full plate/leftover enumeration — lives in `OpenNest.Engine.Tests/Jobs/NestJobExampleTests.cs`.
+
+**Legacy caller boundaries (not yet migrated):** the desktop UI (`MainForm.RunAutoNestAsync` / `NestSinglePlateAsync`), the CLI (`OpenNest.Console`), and MCP (`NestingTools`) still call the old single-plate `engine.Nest(...)` entry points unchanged. UI adoption needs a separate adapter preserving populated-plate editing, preview routing, and Accept-versus-Cancel semantics. The public API (`OpenNest.Api`, `NestRunner.RunAsync`) already delegates to one `NestJobRunner.Solve` call and reports status, stop reason, part fulfillment, stock usage, and plate-to-stock mapping; `.nestquote` archives carry a schema version and round-trip incomplete jobs.
 
 ### Run
 
@@ -162,6 +166,23 @@ dotnet run --project OpenNest.Console/OpenNest.Console.csproj -- project.zip ext
 | `--no-save` | Skip saving the output file |
 | `--no-log` | Skip writing the debug log |
 
+## Benchmarking Nest Engines
+
+`OpenNest.Benchmark` compares every registered `INestingEngine` implementation against each other on a set of `.nest` files, scoring by material utilization. Each engine owns its own multi-plate/size strategy for the whole job — how many plates it uses, of which sizes, and how demand splits across them:
+
+```bash
+# Benchmark all registered engines against every .nest file in a folder
+dotnet run --project OpenNest.Benchmark/OpenNest.Benchmark.csproj -- ./benchmark-jobs
+
+# Sweep a fixed list of sheet sizes instead of each file's own, limit to specific engines
+dotnet run --project OpenNest.Benchmark/OpenNest.Benchmark.csproj -- job.nest \
+  --sheet-sizes 48x96,60x96,60x120,72x120,72x144 --engines Default,Astra,Claude --csv results.csv
+```
+
+An engine's layout is rejected (scoring zero for that job) if any part falls outside the work area, any two parts are closer than the required spacing, or a drawing gets more parts placed than requested. A run that doesn't finish within its time budget also scores zero, as a timeout.
+
+Custom competitor engines can be added by dropping a DLL implementing `INestingEngine` with a public parameterless constructor into the `Engines/` directory next to the benchmark executable; each one is registered under its own CLR type name. This is a separate plugin contract from the desktop app's `NestEngineRegistry`/`NestEngineBase` (which requires a `(Plate)` constructor) — a `NestEngineBase` plugin dropped into the benchmark's `Engines/` folder is silently skipped, since the benchmark only ever solves whole jobs.
+
 ## Project Structure
 
 ```
@@ -176,6 +197,7 @@ OpenNest.sln
 ├── OpenNest.Data/              # Machine configuration and cutting parameters
 ├── OpenNest.Gpu/               # GPU-accelerated pair evaluation (ILGPU)
 ├── OpenNest.Training/          # ML training data collection (SQLite + EF Core)
+├── OpenNest.Benchmark/         # Head-to-head comparison of registered nest engines
 ├── OpenNest.Mcp/               # MCP server for AI tool integration
 ├── OpenNest.Posts.Cincinnati/  # Cincinnati CL-707 laser post-processor plugin
 └── OpenNest.Tests/             # Unit tests (xUnit)
@@ -193,8 +215,74 @@ OpenNest.sln
 | **OpenNest.Gpu** | GPU-accelerated bitmap overlap detection for best-fit pair evaluation using ILGPU. |
 | **OpenNest.Posts.Cincinnati** | Post-processor plugin for Cincinnati CL-707/800/900/940/CLX laser cutting machines. Outputs Cincinnati-format G-code with material library, kerf compensation, and pierce logic. |
 | **OpenNest.Mcp** | MCP (Model Context Protocol) server exposing nesting operations as tools for AI assistants. |
+| **OpenNest.Benchmark** | Runs every registered whole-job nesting engine (`INestingEngine`) against a set of `.nest` files and scores them by material utilization, so competing engines — each owning its own multi-plate strategy — can be compared head-to-head. |
 | **OpenNest.Tests** | 89 test files covering core geometry, fill strategies, splitting, bending, BOM import, post-processing, and the API. |
 
+### StockLadder whole-job baseline
+
+Select `new StockLadderNestingEngine().Solve(job)` or the whole-job registry's
+`StockLadder` engine (benchmark: `--engines StockLadder`). This does not switch the
+legacy desktop single-plate engine. Supply every allowed `NestPlateStock` explicitly;
+no stock sizes are invented. Stock quantity `null` means unlimited, `0` unavailable,
+and a positive quantity is finite inventory. The benchmark's `--sheet-sizes` pool
+uses unlimited quantities; use the job API for finite stock.
+
+```csharp
+var job = new NestJob(parts, callerStocks,
+    new NestJobOptions(maxPlates: 100, salvageRate: 0,
+        minimumSalvageDimension: 0));
+var result = new StockLadderNestingEngine().Solve(job, token: cancellationToken);
+```
+
+Construction orders by priority, then validated stock-fit scarcity, then part area,
+pins an anchor before fillers, and ranks candidate sheets by estimated net sheet
+area per placed part area. Repacking tries single-sheet replacements and adjacent
+pairs into one sheet, accepting only strictly lower estimated net area with exactly
+the same demand. Failed trials leave placements and finite stock accounting intact.
+
+Salvage is an **area estimate**, not price or certified recoverable material.
+`salvageRate` defaults to `0` (allowed range 0–1); `minimumSalvageDimension` defaults
+to `0`, which also disables credit. With both enabled, only the largest qualifying
+full-span edge rectangle outside placed bounding boxes plus part spacing is credited,
+within the usable work area; both dimensions must meet the minimum in job units.
+Holes/scraps are not credited. No cut-off toolpath, kerf, handling, or future-demand
+valuation is modeled. Benchmark ranking still uses gross material utilization.
+
+This is a tested deterministic heuristic baseline, **not an optimal or production-
+certified solver**. Conservative rectangular free-region hints and linear fills can
+miss concave interlocks and feasible layouts. Automatic rotation tries cardinal
+angles plus 5-degree increments below 180 degrees; fixed/range policies are honored.
+Repacking is bounded local search, not a global stock/demand search or fixed-point
+optimality proof. `NoPlacementFound` is not proof of impossibility. Cancellation is
+cooperative (the benchmark requests it after five minutes), not process isolation.
+Geometry acceptance remains strict, including open marks leaving closed material.
+
+Benchmark export example (use a separate output directory):
+
+```bash
+dotnet run --project OpenNest.Benchmark -- input.nest \
+  --engines StockLadder --sheet-sizes 48x96,48x120,48x144,60x96,60x120,60x144,72x96,72x120,72x144 \
+  --salvage-rate 0 --min-salvage-dimension 0 \
+  --output ./stockladder-output --csv ./stockladder.csv
+```
+
+`--output` writes validated layouts as `.nest` plus JSON containing status, stop
+reason, fulfillment, stock usage, poses, and gross/estimated net area. Valid but
+incomplete layouts may be exported: inspect status and fulfillment. Thrown/invalid
+runs do not export layouts. The console can exit zero despite a reported `CRASH`;
+inspect the report, not just the process exit code. Export does not certify cutting
+readiness and must not overwrite the source.
+
+**Known real-input blocker (no successful real-file result):**
+`/srv/shared/P260805-10_dxf/P260805-10.nest` requests 219 pieces from 69 drawings.
+With the nine caller-supplied sizes above, strict validation rejects drawing ID `57`,
+`4980 A01 PT75`: its open mark from `(-5.21875, -1.807287)` to
+`(-4.21875, -1.807287)` starts `0.0001` outside the perimeter's vertical edge at
+`x = -5.21865`. Error: `Geometry must contain usable closed edges: 57. Open geometry
+leaves the closed material region. (Parameter 'job')`. No snapping, clipping, or
+source geometry changes were made. Source SHA-256:
+`9e839fd51072587ec4f3173dc2f39ef1ea8ae460971889c2a3b91fa54b61091d`.
+
 ## Nesting Engines
 
 OpenNest uses a pluggable engine architecture. The active engine can be selected at runtime.