fix(engine): default FillContext.Policy to avoid null-deref in ReportProgress

FillContext.ReportProgress dereferences Policy.Comparer, so any caller
that forgot to set Policy hit a NullReferenceException. Default to
FillPolicy(DefaultFillComparer) so tests and ad-hoc callers work without
boilerplate.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.gitignore

@@ -211,8 +211,5 @@ FakesAssemblies/
 .superpowers/
 docs/superpowers/
 
-# Documentation (manuals, templates, etc.)
-docs/
-
 # Launch settings
 **/Properties/launchSettings.json

CLAUDE.md

@@ -24,10 +24,10 @@ Eight projects form a layered architecture:
 Domain model, geometry, and CNC primitives organized into namespaces:
 
 - **Root** (`namespace OpenNest`): Domain model — `Nest` → `Plate[]` → `Part[]` → `Drawing` → `Program`. A `Nest` is the top-level container. Each `Plate` has a size, material, quadrant, spacing, and contains placed `Part` instances. Each `Part` references a `Drawing` (the template) and has its own location/rotation. A `Drawing` wraps a CNC `Program`. Also contains utilities: `PartGeometry`, `Align`, `Sequence`, `Timing`.
-- **CNC** (`CNC/`, `namespace OpenNest.CNC`): `Program` holds a list of `ICode` instructions (G-code-like: `RapidMove`, `LinearMove`, `ArcMove`, `SubProgramCall`). Programs support absolute/incremental mode conversion, rotation, offset, bounding box calculation, and cloning.
+- **CNC** (`CNC/`, `namespace OpenNest.CNC`): `Program` holds a list of `ICode` instructions (G-code-like: `RapidMove`, `LinearMove`, `ArcMove`, `SubProgramCall`) and an optional `Variables` dictionary of `VariableDefinition` entries. Programs support absolute/incremental mode conversion, rotation, offset, bounding box calculation, and cloning. `VariableDefinition` stores a named variable's expression, resolved value, and flags (`Inline`, `Global`). `ProgramVariableManager` manages numbered machine variables for post-processor output.
 - **Geometry** (`Geometry/`, `namespace OpenNest.Geometry`): Spatial primitives (`Vector`, `Box`, `Size`, `Spacing`, `BoundingBox`, `IBoundable`) and higher-level shapes (`Line`, `Arc`, `Circle`, `Polygon`, `Shape`) used for intersection detection, area calculation, and DXF conversion. Also contains `Intersect` (intersection algorithms), `ShapeBuilder` (entity chaining), `GeometryOptimizer` (line/arc merging), `SpatialQuery` (directional distance, ray casting, box queries), `ShapeProfile` (perimeter/area analysis), `NoFitPolygon`, `InnerFitPolygon`, `ConvexHull`, `ConvexDecomposition`, `RotatingCalipers`, and `Collision` (overlap detection with Sutherland-Hodgman polygon clipping and hole subtraction).
 - **Converters** (`Converters/`, `namespace OpenNest.Converters`): Bridges between CNC and Geometry — `ConvertProgram` (CNC→Geometry), `ConvertGeometry` (Geometry→CNC), `ConvertMode` (absolute↔incremental).
-- **Math** (`Math/`, `namespace OpenNest.Math`): `Angle` (radian/degree conversion), `Tolerance` (floating-point comparison), `Trigonometry`, `Generic` (swap utility), `EvenOdd`, `Rounding` (factor-based rounding). Note: `OpenNest.Math` shadows `System.Math` — use `System.Math` fully qualified where both are needed.
+- **Math** (`Math/`, `namespace OpenNest.Math`): `Angle` (radian/degree conversion), `Tolerance` (floating-point comparison), `Trigonometry`, `Generic` (swap utility), `EvenOdd`, `Rounding` (factor-based rounding), `ExpressionEvaluator` (arithmetic expression parser for G-code variable expressions with `$name` references). Note: `OpenNest.Math` shadows `System.Math` — use `System.Math` fully qualified where both are needed.
 - **CNC/CuttingStrategy** (`CNC/CuttingStrategy/`, `namespace OpenNest.CNC`): `ContourCuttingStrategy` orchestrates cut ordering, lead-ins/lead-outs, and tabs. Includes `LeadIn`/`LeadOut` hierarchies (line, arc, clean-hole variants), `Tab` hierarchy (normal, machine, breaker), and `CuttingParameters`/`AssignmentParameters`/`SequenceParameters` configuration.
 - **Collections** (`Collections/`, `namespace OpenNest.Collections`): `ObservableList<T>`, `DrawingCollection`.
 - **CutOffs** (`namespace OpenNest`): `CutOff` (axis-aligned cut line with position, axis, optional start/end limits), `CutOffAxis` enum (`Horizontal`, `Vertical`), `CutOffSettings` (clearance, overtravel, min segment length, direction), `CutDirection` enum (`TowardOrigin`, `AwayFromOrigin`). Cut-offs generate CNC `Program` objects with trimmed line segments that avoid parts.
@@ -57,6 +57,8 @@ File I/O and format conversion. Uses ACadSharp for DXF/DWG support.
 - `NestReader`/`NestWriter` — custom ZIP-based nest format (JSON metadata + G-code programs, v2 format).
 - `ProgramReader` — G-code text parser.
 - `Extensions` — conversion helpers between ACadSharp and OpenNest geometry types.
+- `CadImporter` — shared "DXF → Drawing" service used by the UI, console, MCP, API, and training projects. Two-stage API: `Import(path, options)` loads raw entities, runs bend detection, and returns a mutable `CadImportResult`; `BuildDrawing(result, visible, bends, quantity, customer, editedProgram)` produces a fully-populated `Drawing` with `Source.Offset`, `SourceEntities`, `SuppressedEntityIds`, and bends. `ImportDrawing(path, options)` composes both stages for headless callers.
+- `CadImportOptions`, `CadImportResult` — inputs and intermediate state for `CadImporter`.
 
 ### OpenNest.Console (console app, depends on Core + Engine + IO)
 Command-line interface for batch nesting. Supports DXF import, plate configuration, linear fill, and NFP-based auto-nesting (`--autonest`).
@@ -116,3 +118,5 @@ Always keep `README.md` and `CLAUDE.md` up to date when making changes that affe
 - `Compactor` performs post-fill gravity compaction — after filling, parts are pushed toward a plate edge using directional distance calculations to close gaps between irregular shapes.
 - `FillScore` uses lexicographic comparison (count > utilization > compactness) to rank fill results consistently across all fill strategies.
 - **Cut-off materialization lifecycle**: `CutOff` objects live on `Plate.CutOffs`. Each generates a `Drawing` (with `IsCutOff = true`) whose `Program` contains trimmed line segments. `Plate.RegenerateCutOffs(settings)` removes old cut-off Parts, recomputes programs, and re-adds them to `Plate.Parts`. Regeneration triggers: cut-off add/remove/move, part drag complete, fill complete, plate transform. Cut-off Parts are excluded from quantity tracking, utilization, overlap detection, and nest file serialization (programs are regenerated from definitions on load).
+- **User-defined G-code variables**: Programs can contain named variable definitions (`name = expression [inline] [global]`) referenced in coordinates with `$name`. Variables resolve to doubles at parse time for geometry/nesting. `VariableRefs` on `Motion`/`Feedrate` track the symbolic link so post processors can emit machine variable references. Cincinnati post maps non-inline variables to numbered machine variables (`#200+`) with descriptive comments. Global variables share a number across programs; local variables get per-drawing numbers. `ProgramReader` uses a two-pass parse (collect definitions, then parse G-code with substitution). `NestWriter` serializes definitions and `$references` back to text for round-trip fidelity.
+- **CAD import pipeline**: All "DXF → Drawing" conversion goes through `OpenNest.IO.CadImporter`. The UI form uses `Import` on file load (storing the mutable result in a `FileListItem`) and `BuildDrawing` on save (passing the user's current visible entities and bends). Console, MCP, API, and Training projects use `ImportDrawing` for headless conversion. This guarantees all callers produce drawings with the same shape: pierce-point `Source.Offset`, stable `SourceEntities` with GUIDs, `SuppressedEntityIds`, detected bends, and metadata.

OpenNest.Api/NestRunner.cs

@@ -5,8 +5,6 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using OpenNest.Converters;
-using OpenNest.Geometry;
 using OpenNest.IO;
 
 namespace OpenNest.Api;
@@ -25,21 +23,26 @@ public static class NestRunner
 
         // 1. Import DXFs → Drawings
         var drawings = new List<Drawing>();
-        var importer = new DxfImporter();
-
         foreach (var part in request.Parts)
         {
             if (!File.Exists(part.DxfPath))
                 throw new FileNotFoundException($"DXF file not found: {part.DxfPath}", part.DxfPath);
 
-            if (!importer.GetGeometry(part.DxfPath, out var geometry) || geometry.Count == 0)
+            Drawing drawing;
+            try
+            {
+                drawing = CadImporter.ImportDrawing(part.DxfPath,
+                    new CadImportOptions { Quantity = part.Quantity });
+            }
+            catch (System.Exception ex)
+            {
+                throw new InvalidOperationException(
+                    $"Failed to import DXF: {part.DxfPath}", ex);
+            }
+
+            if (drawing.Program == null || drawing.Program.Codes.Count == 0)
                 throw new InvalidOperationException($"Failed to import DXF: {part.DxfPath}");
 
-            var normalized = ShapeProfile.NormalizeEntities(geometry);
-            var pgm = ConvertGeometry.ToProgram(normalized);
-            var name = Path.GetFileNameWithoutExtension(part.DxfPath);
-            var drawing = new Drawing(name);
-            drawing.Program = pgm;
             drawings.Add(drawing);
         }
 
@@ -59,6 +62,8 @@ public static class NestRunner
 
         // 3. Multi-plate loop
         var nest = new Nest();
+        nest.Thickness = request.Thickness;
+        nest.Material = new Material(request.Material);
         var remaining = items.Select(item => item.Quantity).ToList();
 
         while (remaining.Any(q => q > 0))
@@ -67,9 +72,7 @@ public static class NestRunner
 
             var plate = new Plate(request.SheetSize)
             {
-                Thickness = request.Thickness,
                 PartSpacing = request.Spacing,
-                Material = new Material(request.Material)
             };
 
             // Build items for this pass with remaining quantities

OpenNest.Console/Program.cs

@@ -1,5 +1,4 @@
 using OpenNest;
-using OpenNest.Converters;
 using OpenNest.Geometry;
 using OpenNest.IO;
 using System;
@@ -241,31 +240,15 @@ static class NestConsole
 
     static Drawing ImportDxf(string path)
     {
-        var importer = new DxfImporter();
+        try
-
-        if (!importer.GetGeometry(path, out var geometry))
         {
-            Console.Error.WriteLine($"Error: failed to read DXF file: {path}");
+            return CadImporter.ImportDrawing(path);
+        }
+        catch (System.Exception ex)
+        {
+            Console.Error.WriteLine($"Error: failed to import DXF '{path}': {ex.Message}");
             return null;
         }
-
-        if (geometry.Count == 0)
-        {
-            Console.Error.WriteLine($"Error: no geometry found in DXF file: {path}");
-            return null;
-        }
-
-        var normalized = ShapeProfile.NormalizeEntities(geometry);
-        var pgm = ConvertGeometry.ToProgram(normalized);
-
-        if (pgm == null)
-        {
-            Console.Error.WriteLine($"Error: failed to convert geometry: {path}");
-            return null;
-        }
-
-        var name = Path.GetFileNameWithoutExtension(path);
-        return new Drawing(name, pgm);
     }
 
     static void ApplyTemplate(Plate plate, Options options)
@@ -279,10 +262,9 @@ static class NestConsole
             return;
         }
 
-        var templatePlate = new NestReader(options.TemplateFile).Read().PlateDefaults.CreateNew();
+        var templateNest = new NestReader(options.TemplateFile).Read();
-        plate.Thickness = templatePlate.Thickness;
+        var templatePlate = templateNest.PlateDefaults.CreateNew();
         plate.Quadrant = templatePlate.Quadrant;
-        plate.Material = templatePlate.Material;
         plate.EdgeSpacing = templatePlate.EdgeSpacing;
         plate.PartSpacing = templatePlate.PartSpacing;
         Console.WriteLine($"Template: {options.TemplateFile}");

OpenNest.Core/CNC/ArcMove.cs

@@ -1,4 +1,5 @@
-using OpenNest.Geometry;
+using System.Collections.Generic;
+using OpenNest.Geometry;
 
 namespace OpenNest.CNC
 {
@@ -65,7 +66,9 @@ namespace OpenNest.CNC
         {
             return new ArcMove(EndPoint, CenterPoint, Rotation)
             {
-                Layer = Layer
+                Layer = Layer,
+                Suppressed = Suppressed,
+                VariableRefs = VariableRefs != null ? new Dictionary<string, string>(VariableRefs) : null
             };
         }
 

OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs

@@ -1,4 +1,6 @@
 using OpenNest.Geometry;
+using OpenNest.Math;
+using System;
 using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
@@ -7,69 +9,332 @@ namespace OpenNest.CNC.CuttingStrategy
     {
         public CuttingParameters Parameters { get; set; }
 
+        private record ContourEntry(Shape Shape, Vector Point, Entity Entity);
+
         public CuttingResult Apply(Program partProgram, Vector approachPoint)
         {
-            var exitPoint = approachPoint;
+            return Apply(partProgram, approachPoint, Vector.Invalid);
+        }
+
+        public CuttingResult Apply(Program partProgram, Vector approachPoint, Vector nextPartStart)
+        {
             var entities = partProgram.ToGeometry();
+            entities.RemoveAll(e => e.Layer == SpecialLayers.Rapid);
+
+            var scribeEntities = entities.FindAll(e => e.Layer == SpecialLayers.Scribe);
+            entities.RemoveAll(e => e.Layer == SpecialLayers.Scribe);
+
             var profile = new ShapeProfile(entities);
 
-            // Find closest point on perimeter from exit point
+            // Start from the bounding box corner opposite the origin (max X, max Y)
-            var perimeterPoint = profile.Perimeter.ClosestPointTo(exitPoint, out var perimeterEntity);
+            var bbox = entities.GetBoundingBox();
+            var startCorner = new Vector(bbox.Right, bbox.Top);
 
-            // Chain cutouts by nearest-neighbor from perimeter point, then reverse
+            // Initial pass: sequence cutouts from bbox corner
-            // so farthest cutouts are cut first, nearest-to-perimeter cut last
+            var seedPoint = startCorner;
-            var orderedCutouts = SequenceCutouts(profile.Cutouts, perimeterPoint);
+            var orderedCutouts = SequenceCutouts(profile.Cutouts, seedPoint);
             orderedCutouts.Reverse();
 
-            // Build output program: cutouts first (farthest to nearest), perimeter last
+            var perimeterSeed = profile.Perimeter.ClosestPointTo(seedPoint, out _);
-            var result = new Program();
+            var cutoutEntries = ResolveLeadInPoints(orderedCutouts, perimeterSeed);
-            var currentPoint = exitPoint;
 
-            foreach (var cutout in orderedCutouts)
+            Vector perimeterPt;
+            Entity perimeterEntity;
+
+            if (!double.IsNaN(nextPartStart.X) && cutoutEntries.Count > 0)
             {
-                var contourType = DetectContourType(cutout);
+                // Iterate: each pass refines the perimeter lead-in which changes
-                var closestPt = cutout.ClosestPointTo(currentPoint, out var entity);
+                // the internal sequence which changes the last cutout position
-                var normal = ComputeNormal(closestPt, entity, contourType);
+                for (var iter = 0; iter < 3; iter++)
-                var winding = DetermineWinding(cutout);
+                {
+                    var lastCutoutPt = cutoutEntries[cutoutEntries.Count - 1].Point;
+                    perimeterSeed = FindPerimeterIntersection(profile.Perimeter, lastCutoutPt, nextPartStart, out _);
 
-                var leadIn = SelectLeadIn(contourType);
+                    orderedCutouts = SequenceCutouts(profile.Cutouts, perimeterSeed);
-                var leadOut = SelectLeadOut(contourType);
+                    orderedCutouts.Reverse();
+                    cutoutEntries = ResolveLeadInPoints(orderedCutouts, perimeterSeed);
+                }
 
-                result.Codes.AddRange(leadIn.Generate(closestPt, normal, winding));
+                var finalLastCutout = cutoutEntries[cutoutEntries.Count - 1].Point;
-                var reindexed = cutout.ReindexAt(closestPt, entity);
+                perimeterPt = FindPerimeterIntersection(profile.Perimeter, finalLastCutout, nextPartStart, out perimeterEntity);
-                result.Codes.AddRange(ConvertShapeToMoves(reindexed, closestPt));
+            }
-                // TODO: MicrotabLeadOut — trim last cutting move by GapSize
+            else
-                result.Codes.AddRange(leadOut.Generate(closestPt, normal, winding));
+            {
-
+                var perimeterRef = cutoutEntries.Count > 0 ? cutoutEntries[0].Point : approachPoint;
-                currentPoint = closestPt;
+                perimeterPt = profile.Perimeter.ClosestPointTo(perimeterRef, out perimeterEntity);
             }
 
-            var lastCutPoint = exitPoint;
+            var result = new Program(Mode.Absolute);
 
-            // Perimeter last
+            EmitScribeContours(result, scribeEntities);
-            {
-                var perimeterPt = profile.Perimeter.ClosestPointTo(currentPoint, out perimeterEntity);
-                lastCutPoint = perimeterPt;
-                var normal = ComputeNormal(perimeterPt, perimeterEntity, ContourType.External);
-                var winding = DetermineWinding(profile.Perimeter);
 
-                var leadIn = SelectLeadIn(ContourType.External);
+            foreach (var entry in cutoutEntries)
-                var leadOut = SelectLeadOut(ContourType.External);
+                EmitContour(result, entry.Shape, entry.Point, entry.Entity);
 
-                result.Codes.AddRange(leadIn.Generate(perimeterPt, normal, winding));
+            EmitContour(result, profile.Perimeter, perimeterPt, perimeterEntity, ContourType.External);
-                var reindexed = profile.Perimeter.ReindexAt(perimeterPt, perimeterEntity);
+
-                result.Codes.AddRange(ConvertShapeToMoves(reindexed, perimeterPt));
+            result.Mode = Mode.Incremental;
-                // TODO: MicrotabLeadOut — trim last cutting move by GapSize
-                result.Codes.AddRange(leadOut.Generate(perimeterPt, normal, winding));
-            }
 
             return new CuttingResult
             {
                 Program = result,
-                LastCutPoint = lastCutPoint
+                LastCutPoint = perimeterPt
             };
         }
 
+        public CuttingResult ApplySingle(Program partProgram, Vector point, Entity entity, ContourType contourType)
+        {
+            var entities = partProgram.ToGeometry();
+            entities.RemoveAll(e => e.Layer == SpecialLayers.Rapid);
+
+            var scribeEntities = entities.FindAll(e => e.Layer == SpecialLayers.Scribe);
+            entities.RemoveAll(e => e.Layer == SpecialLayers.Scribe);
+
+            var profile = new ShapeProfile(entities);
+
+            var result = new Program(Mode.Absolute);
+
+            EmitScribeContours(result, scribeEntities);
+
+            // Find the target shape that contains the clicked entity
+            var (targetShape, matchedEntity) = FindTargetShape(profile, point, entity);
+
+            // Emit cutouts — only the target gets lead-in/out
+            foreach (var cutout in profile.Cutouts)
+            {
+                if (cutout == targetShape)
+                {
+                    var ct = DetectContourType(cutout);
+                    EmitContour(result, cutout, point, matchedEntity, ct);
+                }
+                else
+                {
+                    EmitRawContour(result, cutout);
+                }
+            }
+
+            // Emit perimeter
+            if (profile.Perimeter == targetShape)
+            {
+                EmitContour(result, profile.Perimeter, point, matchedEntity, ContourType.External);
+            }
+            else
+            {
+                EmitRawContour(result, profile.Perimeter);
+            }
+
+            result.Mode = Mode.Incremental;
+
+            return new CuttingResult
+            {
+                Program = result,
+                LastCutPoint = point
+            };
+        }
+
+        private static (Shape Shape, Entity Entity) FindTargetShape(ShapeProfile profile, Vector point, Entity clickedEntity)
+        {
+            var matched = FindMatchingEntity(profile.Perimeter, clickedEntity);
+            if (matched != null)
+                return (profile.Perimeter, matched);
+
+            foreach (var cutout in profile.Cutouts)
+            {
+                matched = FindMatchingEntity(cutout, clickedEntity);
+                if (matched != null)
+                    return (cutout, matched);
+            }
+
+            // Fallback: closest shape, use closest point to find entity
+            var best = profile.Perimeter;
+            var bestPt = profile.Perimeter.ClosestPointTo(point, out var bestEntity);
+            var bestDist = bestPt.DistanceTo(point);
+
+            foreach (var cutout in profile.Cutouts)
+            {
+                var pt = cutout.ClosestPointTo(point, out var cutoutEntity);
+                var dist = pt.DistanceTo(point);
+                if (dist < bestDist)
+                {
+                    best = cutout;
+                    bestEntity = cutoutEntity;
+                    bestDist = dist;
+                }
+            }
+
+            return (best, bestEntity);
+        }
+
+        private static Entity FindMatchingEntity(Shape shape, Entity clickedEntity)
+        {
+            foreach (var shapeEntity in shape.Entities)
+            {
+                if (shapeEntity.GetType() != clickedEntity.GetType())
+                    continue;
+
+                if (shapeEntity is Line sLine && clickedEntity is Line cLine)
+                {
+                    if (sLine.StartPoint.DistanceTo(cLine.StartPoint) < Math.Tolerance.Epsilon
+                        && sLine.EndPoint.DistanceTo(cLine.EndPoint) < Math.Tolerance.Epsilon)
+                        return shapeEntity;
+                }
+                else if (shapeEntity is Arc sArc && clickedEntity is Arc cArc)
+                {
+                    if (System.Math.Abs(sArc.Radius - cArc.Radius) < Math.Tolerance.Epsilon
+                        && sArc.Center.DistanceTo(cArc.Center) < Math.Tolerance.Epsilon)
+                        return shapeEntity;
+                }
+                else if (shapeEntity is Circle sCircle && clickedEntity is Circle cCircle)
+                {
+                    if (System.Math.Abs(sCircle.Radius - cCircle.Radius) < Math.Tolerance.Epsilon
+                        && sCircle.Center.DistanceTo(cCircle.Center) < Math.Tolerance.Epsilon)
+                        return shapeEntity;
+                }
+            }
+
+            return null;
+        }
+
+        private void EmitRawContour(Program program, Shape shape)
+        {
+            var startPoint = GetShapeStartPoint(shape);
+            program.Codes.Add(new RapidMove(startPoint));
+            program.Codes.AddRange(ConvertShapeToMoves(shape, startPoint));
+        }
+
+        private static List<ContourEntry> ResolveLeadInPoints(List<Shape> cutouts, Vector startPoint)
+        {
+            var entries = new ContourEntry[cutouts.Count];
+            var currentPoint = startPoint;
+
+            // Walk backward through cutting order (from perimeter outward)
+            // so each cutout's lead-in point faces the next cutout to be cut
+            for (var i = cutouts.Count - 1; i >= 0; i--)
+            {
+                var closestPt = cutouts[i].ClosestPointTo(currentPoint, out var entity);
+                entries[i] = new ContourEntry(cutouts[i], closestPt, entity);
+                currentPoint = closestPt;
+            }
+
+            return new List<ContourEntry>(entries);
+        }
+
+        private static Vector FindPerimeterIntersection(Shape perimeter, Vector lastCutout, Vector nextPartStart, out Entity entity)
+        {
+            var ray = new Line(lastCutout, nextPartStart);
+
+            if (perimeter.Intersects(ray, out var pts) && pts.Count > 0)
+            {
+                // Pick the intersection closest to the last cutout
+                var best = pts[0];
+                var bestDist = best.DistanceTo(lastCutout);
+
+                for (var i = 1; i < pts.Count; i++)
+                {
+                    var dist = pts[i].DistanceTo(lastCutout);
+                    if (dist < bestDist)
+                    {
+                        best = pts[i];
+                        bestDist = dist;
+                    }
+                }
+
+                return perimeter.ClosestPointTo(best, out entity);
+            }
+
+            // Fallback: closest point on perimeter to the last cutout
+            return perimeter.ClosestPointTo(lastCutout, out entity);
+        }
+
+        private static int ComputeSubProgramKey(double radius, double normalAngle)
+        {
+            var r = System.Math.Round(radius, 6);
+            var a = System.Math.Round(normalAngle, 6);
+            return HashCode.Combine(r, a);
+        }
+
+        private void EmitContour(Program program, Shape shape, Vector point, Entity entity, ContourType? forceType = null)
+        {
+            var contourType = forceType ?? DetectContourType(shape);
+            var winding = DetermineWinding(shape);
+            var normal = ComputeNormal(point, entity, contourType, winding);
+
+            var leadIn = SelectLeadIn(contourType);
+            var leadOut = SelectLeadOut(contourType);
+
+            if (contourType == ContourType.ArcCircle && entity is Circle circle)
+            {
+                if (Parameters.RoundLeadInAngles && Parameters.LeadInAngleIncrement > 0)
+                {
+                    var increment = Angle.ToRadians(Parameters.LeadInAngleIncrement);
+                    normal = System.Math.Round(normal / increment) * increment;
+                    normal = Angle.NormalizeRad(normal);
+
+                    var outwardAngle = normal - System.Math.PI;
+                    point = new Vector(
+                        circle.Center.X + circle.Radius * System.Math.Cos(outwardAngle),
+                        circle.Center.Y + circle.Radius * System.Math.Sin(outwardAngle));
+                }
+
+                leadIn = ClampLeadInForCircle(leadIn, circle, point, normal);
+
+                // Build hole sub-program relative to (0,0)
+                var holeCenter = circle.Center;
+                var relativePoint = new Vector(point.X - holeCenter.X, point.Y - holeCenter.Y);
+                var relativeCircle = new Circle(new Vector(0, 0), circle.Radius) { Rotation = circle.Rotation };
+                var relativeShape = new Shape();
+                relativeShape.Entities.Add(relativeCircle);
+
+                var subPgm = new Program(Mode.Absolute);
+                subPgm.Codes.AddRange(leadIn.Generate(relativePoint, normal, winding));
+                var reindexed = relativeShape.ReindexAt(relativePoint, relativeCircle);
+
+                if (Parameters.TabsEnabled && Parameters.TabConfig != null)
+                    reindexed = TrimShapeForTab(reindexed, relativePoint, Parameters.TabConfig.Size);
+
+                subPgm.Codes.AddRange(ConvertShapeToMoves(reindexed, relativePoint));
+                subPgm.Codes.AddRange(leadOut.Generate(relativePoint, normal, winding));
+                subPgm.Mode = Mode.Incremental;
+
+                // Deduplicate: check if an identical sub-program already exists
+                var key = ComputeSubProgramKey(circle.Radius, normal);
+                if (!program.SubPrograms.ContainsKey(key))
+                    program.SubPrograms[key] = subPgm;
+
+                program.Codes.Add(new SubProgramCall
+                {
+                    Id = key,
+                    Program = program.SubPrograms[key],
+                    Offset = holeCenter
+                });
+
+                return;
+            }
+
+            program.Codes.AddRange(leadIn.Generate(point, normal, winding));
+
+            var reindexedShape = shape.ReindexAt(point, entity);
+
+            if (Parameters.TabsEnabled && Parameters.TabConfig != null)
+                reindexedShape = TrimShapeForTab(reindexedShape, point, Parameters.TabConfig.Size);
+
+            program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
+            program.Codes.AddRange(leadOut.Generate(point, normal, winding));
+        }
+
+        private void EmitScribeContours(Program program, List<Entity> scribeEntities)
+        {
+            if (scribeEntities.Count == 0) return;
+
+            var shapes = ShapeBuilder.GetShapes(scribeEntities);
+            foreach (var shape in shapes)
+            {
+                var startPt = GetShapeStartPoint(shape);
+                program.Codes.Add(new RapidMove(startPt));
+                program.Codes.AddRange(ConvertShapeToMoves(shape, startPt, LayerType.Scribe));
+            }
+        }
+
         private List<Shape> SequenceCutouts(List<Shape> cutouts, Vector startPoint)
         {
             var remaining = new List<Shape>(cutouts);
@@ -102,7 +367,7 @@ namespace OpenNest.CNC.CuttingStrategy
             return ordered;
         }
 
-        private ContourType DetectContourType(Shape cutout)
+        public static ContourType DetectContourType(Shape cutout)
         {
             if (cutout.Entities.Count == 1 && cutout.Entities[0] is Circle)
                 return ContourType.ArcCircle;
@@ -110,23 +375,33 @@ namespace OpenNest.CNC.CuttingStrategy
             return ContourType.Internal;
         }
 
-        private double ComputeNormal(Vector point, Entity entity, ContourType contourType)
+        public static double ComputeNormal(Vector point, Entity entity, ContourType contourType,
+            RotationType winding = RotationType.CW)
         {
             double normal;
 
             if (entity is Line line)
             {
-                // Perpendicular to line direction
+                // Perpendicular to line direction: tangent + π/2 = left side.
+                // Left side = outward for CW winding; for CCW winding, outward
+                // is on the right side, so flip.
                 var tangent = line.EndPoint.AngleFrom(line.StartPoint);
                 normal = tangent + Math.Angle.HalfPI;
+                if (winding == RotationType.CCW)
+                    normal += System.Math.PI;
             }
             else if (entity is Arc arc)
             {
-                // Radial direction from center to point
+                // Radial direction from center to point.
+                // Flip when the arc direction differs from the contour winding —
+                // that indicates a concave feature where radial points inward.
                 normal = point.AngleFrom(arc.Center);
+                if (arc.Rotation != winding)
+                    normal += System.Math.PI;
             }
             else if (entity is Circle circle)
             {
+                // Radial outward — always correct regardless of winding
                 normal = point.AngleFrom(circle.Center);
             }
             else
@@ -141,11 +416,61 @@ namespace OpenNest.CNC.CuttingStrategy
             return Math.Angle.NormalizeRad(normal);
         }
 
-        private RotationType DetermineWinding(Shape shape)
+        public static RotationType DetermineWinding(Shape shape)
         {
-            // Use signed area: positive = CCW, negative = CW
+            if (shape.Entities.Count == 1 && shape.Entities[0] is Circle circle)
-            var area = shape.Area();
+                return circle.Rotation;
-            return area >= 0 ? RotationType.CCW : RotationType.CW;
+
+            var polygon = shape.ToPolygon();
+
+            if (polygon.Vertices.Count < 3)
+                return RotationType.CCW;
+
+            return polygon.RotationDirection();
+        }
+
+        private LeadIn ClampLeadInForCircle(LeadIn leadIn, Circle circle, Vector contourPoint, double normalAngle)
+        {
+            if (leadIn is NoLeadIn || Parameters.PierceClearance <= 0)
+                return leadIn;
+
+            var piercePoint = leadIn.GetPiercePoint(contourPoint, normalAngle);
+            var maxRadius = circle.Radius - Parameters.PierceClearance;
+            if (maxRadius <= 0)
+                return leadIn;
+
+            var distFromCenter = piercePoint.DistanceTo(circle.Center);
+            if (distFromCenter <= maxRadius)
+                return leadIn;
+
+            // Compute max distance from contourPoint toward piercePoint that stays
+            // inside a circle of radius maxRadius centered at circle.Center.
+            // Solve: |contourPoint + t*d - center|^2 = maxRadius^2
+            var currentDist = contourPoint.DistanceTo(piercePoint);
+            if (currentDist < Math.Tolerance.Epsilon)
+                return leadIn;
+
+            var dx = (piercePoint.X - contourPoint.X) / currentDist;
+            var dy = (piercePoint.Y - contourPoint.Y) / currentDist;
+            var vx = contourPoint.X - circle.Center.X;
+            var vy = contourPoint.Y - circle.Center.Y;
+
+            var b = 2.0 * (vx * dx + vy * dy);
+            var c = vx * vx + vy * vy - maxRadius * maxRadius;
+            var discriminant = b * b - 4.0 * c;
+
+            if (discriminant < 0)
+                return leadIn;
+
+            var t = (-b + System.Math.Sqrt(discriminant)) / 2.0;
+            if (t <= 0)
+                return leadIn;
+
+            var scale = t / currentDist;
+            if (scale >= 1.0)
+                return leadIn;
+
+            return leadIn.Scale(scale);
         }
 
         private LeadIn SelectLeadIn(ContourType contourType)
@@ -168,7 +493,71 @@ namespace OpenNest.CNC.CuttingStrategy
             };
         }
 
-        private List<ICode> ConvertShapeToMoves(Shape shape, Vector startPoint)
+        private static Shape TrimShapeForTab(Shape shape, Vector center, double tabSize)
+        {
+            var tabCircle = new Circle(center, tabSize);
+            var entities = new List<Entity>(shape.Entities);
+
+            // Trim end: walk backward removing entities inside the tab circle
+            while (entities.Count > 0)
+            {
+                var entity = entities[entities.Count - 1];
+                if (entity.Intersects(tabCircle, out var pts) && pts.Count > 0)
+                {
+                    // Find intersection furthest from center (furthest along path from end)
+                    var best = pts[0];
+                    var bestDist = best.DistanceTo(center);
+                    for (var j = 1; j < pts.Count; j++)
+                    {
+                        var dist = pts[j].DistanceTo(center);
+                        if (dist > bestDist)
+                        {
+                            best = pts[j];
+                            bestDist = dist;
+                        }
+                    }
+
+                    if (entity is Line line)
+                    {
+                        var (first, _) = line.SplitAt(best);
+                        entities.RemoveAt(entities.Count - 1);
+                        if (first != null)
+                            entities.Add(first);
+                    }
+                    else if (entity is Arc arc)
+                    {
+                        var (first, _) = arc.SplitAt(best);
+                        entities.RemoveAt(entities.Count - 1);
+                        if (first != null)
+                            entities.Add(first);
+                    }
+
+                    break;
+                }
+
+                // No intersection — entity is entirely inside circle, remove it
+                if (EntityStartPoint(entity).DistanceTo(center) <= tabSize + Tolerance.Epsilon)
+                {
+                    entities.RemoveAt(entities.Count - 1);
+                    continue;
+                }
+
+                break;
+            }
+
+            var result = new Shape();
+            result.Entities.AddRange(entities);
+            return result;
+        }
+
+        private static Vector EntityStartPoint(Entity entity)
+        {
+            if (entity is Line line) return line.StartPoint;
+            if (entity is Arc arc) return arc.StartPoint();
+            return Vector.Zero;
+        }
+
+        private List<ICode> ConvertShapeToMoves(Shape shape, Vector startPoint, LayerType layer = LayerType.Display)
         {
             var moves = new List<ICode>();
 
@@ -176,15 +565,15 @@ namespace OpenNest.CNC.CuttingStrategy
             {
                 if (entity is Line line)
                 {
-                    moves.Add(new LinearMove(line.EndPoint));
+                    moves.Add(new LinearMove(line.EndPoint) { Layer = layer });
                 }
                 else if (entity is Arc arc)
                 {
-                    moves.Add(new ArcMove(arc.EndPoint(), arc.Center, arc.IsReversed ? RotationType.CW : RotationType.CCW));
+                    moves.Add(new ArcMove(arc.EndPoint(), arc.Center, arc.IsReversed ? RotationType.CW : RotationType.CCW) { Layer = layer });
                 }
                 else if (entity is Circle circle)
                 {
-                    moves.Add(new ArcMove(startPoint, circle.Center, circle.Rotation));
+                    moves.Add(new ArcMove(startPoint, circle.Center, circle.Rotation) { Layer = layer });
                 }
                 else
                 {
@@ -194,5 +583,14 @@ namespace OpenNest.CNC.CuttingStrategy
 
             return moves;
         }
+
+        private static Vector GetShapeStartPoint(Shape shape)
+        {
+            var first = shape.Entities[0];
+            if (first is Line line) return line.StartPoint;
+            if (first is Arc arc) return arc.StartPoint();
+            if (first is Circle circle) return new Vector(circle.Center.X + circle.Radius, circle.Center.Y);
+            return Vector.Zero;
+        }
     }
 }

OpenNest.Core/CNC/CuttingStrategy/CuttingParameters.cs

@@ -21,6 +21,14 @@ namespace OpenNest.CNC.CuttingStrategy
         public LeadIn ArcCircleLeadIn { get; set; } = new NoLeadIn();
         public LeadOut ArcCircleLeadOut { get; set; } = new NoLeadOut();
 
+        public double PierceClearance { get; set; } = 0.0625;
+
+        public bool RoundLeadInAngles { get; set; }
+        public double LeadInAngleIncrement { get; set; } = 5.0;
+
+        public double AutoTabMinSize { get; set; }
+        public double AutoTabMaxSize { get; set; }
+
         public Tab TabConfig { get; set; }
         public bool TabsEnabled { get; set; }
 

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

@@ -19,7 +19,7 @@ namespace OpenNest.CNC.CuttingStrategy
             return new List<ICode>
             {
                 new RapidMove(piercePoint),
-                new ArcMove(contourStartPoint, arcCenter, winding)
+                new ArcMove(contourStartPoint, arcCenter, winding) { Layer = LayerType.Leadin }
             };
         }
 
@@ -32,5 +32,8 @@ namespace OpenNest.CNC.CuttingStrategy
                 arcCenterX + Radius * System.Math.Cos(contourNormalAngle),
                 arcCenterY + Radius * System.Math.Sin(contourNormalAngle));
         }
+
+        public override LeadIn Scale(double factor) =>
+            new ArcLeadIn { Radius = Radius * factor };
     }
 }

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

@@ -27,8 +27,8 @@ namespace OpenNest.CNC.CuttingStrategy
             return new List<ICode>
             {
                 new RapidMove(piercePoint),
-                new LinearMove(arcStart),
+                new LinearMove(arcStart) { Layer = LayerType.Leadin },
-                new ArcMove(contourStartPoint, arcCenter, winding)
+                new ArcMove(contourStartPoint, arcCenter, winding) { Layer = LayerType.Leadin }
             };
         }
 
@@ -45,5 +45,8 @@ namespace OpenNest.CNC.CuttingStrategy
                 arcStartX + LineLength * System.Math.Cos(lineAngle),
                 arcStartY + LineLength * System.Math.Sin(lineAngle));
         }
+
+        public override LeadIn Scale(double factor) =>
+            new CleanHoleLeadIn { LineLength = LineLength * factor, ArcRadius = ArcRadius * factor, Kerf = Kerf };
     }
 }

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

@@ -9,5 +9,7 @@ namespace OpenNest.CNC.CuttingStrategy
             RotationType winding = RotationType.CW);
 
         public abstract Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle);
+
+        public virtual LeadIn Scale(double factor) => this;
     }
 }

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

@@ -27,8 +27,8 @@ namespace OpenNest.CNC.CuttingStrategy
             return new List<ICode>
             {
                 new RapidMove(piercePoint),
-                new LinearMove(arcStart),
+                new LinearMove(arcStart) { Layer = LayerType.Leadin },
-                new ArcMove(contourStartPoint, arcCenter, winding)
+                new ArcMove(contourStartPoint, arcCenter, winding) { Layer = LayerType.Leadin }
             };
         }
 
@@ -45,5 +45,8 @@ namespace OpenNest.CNC.CuttingStrategy
                 arcStartX + LineLength * System.Math.Cos(lineAngle),
                 arcStartY + LineLength * System.Math.Sin(lineAngle));
         }
+
+        public override LeadIn Scale(double factor) =>
+            new LineArcLeadIn { LineLength = LineLength * factor, ArcRadius = ArcRadius * factor, ApproachAngle = ApproachAngle };
     }
 }

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

@@ -17,16 +17,19 @@ namespace OpenNest.CNC.CuttingStrategy
             return new List<ICode>
             {
                 new RapidMove(piercePoint),
-                new LinearMove(contourStartPoint)
+                new LinearMove(contourStartPoint) { Layer = LayerType.Leadin }
             };
         }
 
         public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
         {
-            var approachAngle = contourNormalAngle + Angle.ToRadians(ApproachAngle);
+            var approachAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle);
             return new Vector(
                 contourStartPoint.X + Length * System.Math.Cos(approachAngle),
                 contourStartPoint.Y + Length * System.Math.Sin(approachAngle));
         }
+
+        public override LeadIn Scale(double factor) =>
+            new LineLeadIn { Length = Length * factor, ApproachAngle = ApproachAngle };
     }
 }

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

@@ -16,7 +16,7 @@ namespace OpenNest.CNC.CuttingStrategy
         {
             var piercePoint = GetPiercePoint(contourStartPoint, contourNormalAngle);
 
-            var secondAngle = contourNormalAngle + Angle.ToRadians(ApproachAngle1);
+            var secondAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle1);
             var midPoint = new Vector(
                 contourStartPoint.X + Length2 * System.Math.Cos(secondAngle),
                 contourStartPoint.Y + Length2 * System.Math.Sin(secondAngle));
@@ -24,14 +24,14 @@ namespace OpenNest.CNC.CuttingStrategy
             return new List<ICode>
             {
                 new RapidMove(piercePoint),
-                new LinearMove(midPoint),
+                new LinearMove(midPoint) { Layer = LayerType.Leadin },
-                new LinearMove(contourStartPoint)
+                new LinearMove(contourStartPoint) { Layer = LayerType.Leadin }
             };
         }
 
         public override Vector GetPiercePoint(Vector contourStartPoint, double contourNormalAngle)
         {
-            var secondAngle = contourNormalAngle + Angle.ToRadians(ApproachAngle1);
+            var secondAngle = contourNormalAngle - Angle.HalfPI + Angle.ToRadians(ApproachAngle1);
             var midX = contourStartPoint.X + Length2 * System.Math.Cos(secondAngle);
             var midY = contourStartPoint.Y + Length2 * System.Math.Sin(secondAngle);
 
@@ -40,5 +40,8 @@ namespace OpenNest.CNC.CuttingStrategy
                 midX + Length1 * System.Math.Cos(firstAngle),
                 midY + Length1 * System.Math.Sin(firstAngle));
         }
+
+        public override LeadIn Scale(double factor) =>
+            new LineLineLeadIn { Length1 = Length1 * factor, ApproachAngle1 = ApproachAngle1, Length2 = Length2 * factor, ApproachAngle2 = ApproachAngle2 };
     }
 }

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

@@ -20,7 +20,7 @@ namespace OpenNest.CNC.CuttingStrategy
 
             return new List<ICode>
             {
-                new ArcMove(endPoint, arcCenter, winding)
+                new ArcMove(endPoint, arcCenter, winding) { Layer = LayerType.Leadout }
             };
         }
     }

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

@@ -12,14 +12,14 @@ namespace OpenNest.CNC.CuttingStrategy
         public override List<ICode> Generate(Vector contourEndPoint, double contourNormalAngle,
             RotationType winding = RotationType.CW)
         {
-            var overcutAngle = contourNormalAngle + Angle.ToRadians(ApproachAngle);
+            var overcutAngle = contourNormalAngle + Angle.HalfPI - Angle.ToRadians(ApproachAngle);
             var endPoint = new Vector(
                 contourEndPoint.X + Length * System.Math.Cos(overcutAngle),
                 contourEndPoint.Y + Length * System.Math.Sin(overcutAngle));
 
             return new List<ICode>
             {
-                new LinearMove(endPoint)
+                new LinearMove(endPoint) { Layer = LayerType.Leadout }
             };
         }
     }

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

@@ -1,16 +0,0 @@
-using OpenNest.Geometry;
-using System.Collections.Generic;
-
-namespace OpenNest.CNC.CuttingStrategy
-{
-    public class MicrotabLeadOut : LeadOut
-    {
-        public double GapSize { get; set; } = 0.03;
-
-        public override List<ICode> Generate(Vector contourEndPoint, double contourNormalAngle,
-            RotationType winding = RotationType.CW)
-        {
-            return new List<ICode>();
-        }
-    }
-}

OpenNest.Core/CNC/Feedrate.cs

@@ -17,6 +17,8 @@
 
         public double Value { get; set; }
 
+        public string VariableRef { get; set; }
+
         public CodeType Type
         {
             get { return CodeType.SetFeedrate; }
@@ -24,7 +26,7 @@
 
         public ICode Clone()
         {
-            return new Feedrate(Value);
+            return new Feedrate(Value) { VariableRef = VariableRef };
         }
 
         public override string ToString()

OpenNest.Core/CNC/LinearMove.cs

@@ -1,4 +1,5 @@
-using OpenNest.Geometry;
+using System.Collections.Generic;
+using OpenNest.Geometry;
 
 namespace OpenNest.CNC
 {
@@ -31,7 +32,9 @@ namespace OpenNest.CNC
         {
             return new LinearMove(EndPoint)
             {
-                Layer = Layer
+                Layer = Layer,
+                Suppressed = Suppressed,
+                VariableRefs = VariableRefs != null ? new Dictionary<string, string>(VariableRefs) : null
             };
         }
 

OpenNest.Core/CNC/Motion.cs

@@ -1,4 +1,5 @@
-using OpenNest.Geometry;
+using System.Collections.Generic;
+using OpenNest.Geometry;
 
 namespace OpenNest.CNC
 {
@@ -12,6 +13,10 @@ namespace OpenNest.CNC
 
         public int Feedrate { get; set; }
 
+        public bool Suppressed { get; set; }
+
+        public Dictionary<string, string> VariableRefs { get; set; }
+
         protected Motion()
         {
             Feedrate = CNC.Feedrate.UseDefault;
@@ -20,21 +25,25 @@ namespace OpenNest.CNC
         public virtual void Rotate(double angle)
         {
             EndPoint = EndPoint.Rotate(angle);
+            VariableRefs = null;
         }
 
         public virtual void Rotate(double angle, Vector origin)
         {
             EndPoint = EndPoint.Rotate(angle, origin);
+            VariableRefs = null;
         }
 
         public virtual void Offset(double x, double y)
         {
             EndPoint = new Vector(EndPoint.X + x, EndPoint.Y + y);
+            VariableRefs = null;
         }
 
         public virtual void Offset(Vector voffset)
         {
             EndPoint += voffset;
+            VariableRefs = null;
         }
 
         public abstract CodeType Type { get; }

OpenNest.Core/CNC/Program.cs

@@ -1,6 +1,7 @@
 using OpenNest.Converters;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System;
 using System.Collections.Generic;
 
 namespace OpenNest.CNC
@@ -9,6 +10,10 @@ namespace OpenNest.CNC
     {
         public List<ICode> Codes;
 
+        public Dictionary<string, VariableDefinition> Variables { get; } = new(StringComparer.OrdinalIgnoreCase);
+
+        public Dictionary<int, Program> SubPrograms { get; } = new();
+
         private Mode mode;
 
         public Program(Mode mode = Mode.Absolute)
@@ -84,6 +89,17 @@ namespace OpenNest.CNC
                 {
                     var subpgm = (SubProgramCall)code;
 
+                    if (subpgm.Offset.X != 0 || subpgm.Offset.Y != 0)
+                    {
+                        var cos = System.Math.Cos(angle);
+                        var sin = System.Math.Sin(angle);
+                        var dx = subpgm.Offset.X - origin.X;
+                        var dy = subpgm.Offset.Y - origin.Y;
+                        subpgm.Offset = new Geometry.Vector(
+                            origin.X + dx * cos - dy * sin,
+                            origin.Y + dx * sin + dy * cos);
+                    }
+
                     if (subpgm.Program != null)
                         subpgm.Program.Rotate(angle, origin);
                 }
@@ -112,6 +128,12 @@ namespace OpenNest.CNC
             {
                 var code = Codes[i];
 
+                if (code is SubProgramCall subpgm)
+                {
+                    subpgm.Offset = new Geometry.Vector(
+                        subpgm.Offset.X + x, subpgm.Offset.Y + y);
+                }
+
                 if (code is Motion == false)
                     continue;
 
@@ -134,6 +156,12 @@ namespace OpenNest.CNC
             {
                 var code = Codes[i];
 
+                if (code is SubProgramCall subpgm)
+                {
+                    subpgm.Offset = new Geometry.Vector(
+                        subpgm.Offset.X + voffset.X, subpgm.Offset.Y + voffset.Y);
+                }
+
                 if (code is Motion == false)
                     continue;
 
@@ -272,6 +300,10 @@ namespace OpenNest.CNC
 
         private Box BoundingBox(ref Vector pos)
         {
+            // Capture the frame origin at entry. Sub-program Offsets and
+            // absolute-mode endpoints are relative to this fixed origin.
+            var frameOrigin = pos;
+
             double minX = 0.0;
             double minY = 0.0;
             double maxX = 0.0;
@@ -287,7 +319,7 @@ namespace OpenNest.CNC
                         {
                             var line = (LinearMove)code;
                             var pt = Mode == Mode.Absolute ?
-                                line.EndPoint :
+                                frameOrigin + line.EndPoint :
                                 line.EndPoint + pos;
 
                             if (pt.X > maxX)
@@ -309,7 +341,7 @@ namespace OpenNest.CNC
                         {
                             var line = (RapidMove)code;
                             var pt = Mode == Mode.Absolute
-                                ? line.EndPoint
+                                ? frameOrigin + line.EndPoint
                                 : line.EndPoint + pos;
 
                             if (pt.X > maxX)
@@ -342,8 +374,8 @@ namespace OpenNest.CNC
                             }
                             else
                             {
-                                endpt = arc.EndPoint;
+                                endpt = frameOrigin + arc.EndPoint;
-                                centerpt = arc.CenterPoint;
+                                centerpt = frameOrigin + arc.CenterPoint;
                             }
 
                             double minX1;
@@ -417,6 +449,12 @@ namespace OpenNest.CNC
                     case CodeType.SubProgramCall:
                         {
                             var subpgm = (SubProgramCall)code;
+                            if (subpgm.Program == null)
+                                break;
+
+                            // Sub-program frame origin in this program's frame
+                            // is frameOrigin + Offset, regardless of current pos.
+                            pos = frameOrigin + subpgm.Offset;
                             var box = subpgm.Program.BoundingBox(ref pos);
 
                             if (box.Left < minX)
@@ -454,6 +492,12 @@ namespace OpenNest.CNC
 
             pgm.Codes.AddRange(codes);
 
+            foreach (var kvp in Variables)
+                pgm.Variables[kvp.Key] = kvp.Value;
+
+            foreach (var kvp in SubPrograms)
+                pgm.SubPrograms[kvp.Key] = (Program)kvp.Value.Clone();
+
             return pgm;
         }
 

OpenNest.Core/CNC/RapidMove.cs

@@ -1,4 +1,5 @@
-using OpenNest.Geometry;
+using System.Collections.Generic;
+using OpenNest.Geometry;
 
 namespace OpenNest.CNC
 {
@@ -26,7 +27,11 @@ namespace OpenNest.CNC
 
         public override ICode Clone()
         {
-            return new RapidMove(EndPoint);
+            return new RapidMove(EndPoint)
+            {
+                Suppressed = Suppressed,
+                VariableRefs = VariableRefs != null ? new Dictionary<string, string>(VariableRefs) : null
+            };
         }
 
         public override string ToString()

OpenNest.Core/CNC/SubProgramCall.cs

@@ -1,4 +1,6 @@
-using OpenNest.Math;
+using System.Text;
+using OpenNest.Geometry;
+using OpenNest.Math;
 
 namespace OpenNest.CNC
 {
@@ -35,6 +37,12 @@ namespace OpenNest.CNC
             }
         }
 
+        /// <summary>
+        /// Gets or sets the offset (position) at which the sub-program is executed.
+        /// For hole sub-programs, this is the hole center.
+        /// </summary>
+        public Vector Offset { get; set; }
+
         /// <summary>
         /// Gets or sets the rotation of the program in degrees.
         /// </summary>
@@ -78,12 +86,18 @@ namespace OpenNest.CNC
         /// <returns></returns>
         public ICode Clone()
         {
-            return new SubProgramCall(program, Rotation);
+            return new SubProgramCall(program, Rotation) { Id = Id, Offset = Offset };
         }
 
         public override string ToString()
         {
-            return string.Format("G65 P{0} R{1}", Id, Rotation);
+            var sb = new StringBuilder();
+            sb.Append($"G65 P{Id}");
+            if (Offset.X != 0 || Offset.Y != 0)
+                sb.Append($" X{Offset.X} Y{Offset.Y}");
+            if (Rotation != 0)
+                sb.Append($" R{Rotation}");
+            return sb.ToString();
         }
     }
 }

OpenNest.Core/CNC/VariableDefinition.cs

@@ -0,0 +1,21 @@
+namespace OpenNest.CNC
+{
+    public sealed class VariableDefinition
+    {
+        public string Name { get; }
+        public string Expression { get; }
+        public double Value { get; }
+        public bool Inline { get; }
+        public bool Global { get; }
+
+        public VariableDefinition(string name, string expression, double value,
+            bool inline = false, bool global = false)
+        {
+            Name = name;
+            Expression = expression;
+            Value = value;
+            Inline = inline;
+            Global = global;
+        }
+    }
+}

OpenNest.Core/Collections/ObservableList.cs

@@ -46,7 +46,8 @@ namespace OpenNest.Collections
         public bool Remove(T item)
         {
             var success = items.Remove(item);
-            ItemRemoved?.Invoke(this, new ItemRemovedEventArgs<T>(item, success));
+            if (success)
+                ItemRemoved?.Invoke(this, new ItemRemovedEventArgs<T>(item, success));
             return success;
         }
 

OpenNest.Core/Converters/ContourInfo.cs

@@ -0,0 +1,137 @@
+using OpenNest.Geometry;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest.Converters
+{
+    public enum ContourClassification
+    {
+        Perimeter,
+        Hole,
+        Etch,
+        Open
+    }
+
+    public sealed class ContourInfo
+    {
+        public Shape Shape { get; }
+        public ContourClassification Type { get; private set; }
+        public string Label { get; private set; }
+
+        private ContourInfo(Shape shape, ContourClassification type, string label)
+        {
+            Shape = shape;
+            Type = type;
+            Label = label;
+        }
+
+        public string DirectionLabel
+        {
+            get
+            {
+                if (Type == ContourClassification.Open || Type == ContourClassification.Etch)
+                    return "Open";
+                var poly = Shape.ToPolygon();
+                if (poly == null || poly.Vertices.Count < 3)
+                    return "?";
+                return poly.RotationDirection() == RotationType.CW ? "CW" : "CCW";
+            }
+        }
+
+        public string DimensionLabel
+        {
+            get
+            {
+                if (Shape.Entities.Count == 1 && Shape.Entities[0] is Circle c)
+                    return $"Circle R{c.Radius:0.#}";
+                Shape.UpdateBounds();
+                var box = Shape.BoundingBox;
+                return $"{box.Width:0.#} x {box.Length:0.#}";
+            }
+        }
+
+        public void Reverse()
+        {
+            Shape.Reverse();
+        }
+
+        public void SetLabel(string label)
+        {
+            Label = label;
+        }
+
+        public static List<ContourInfo> Classify(List<Shape> shapes)
+        {
+            if (shapes.Count == 0)
+                return new List<ContourInfo>();
+
+            // Ensure bounding boxes are up to date before comparing
+            foreach (var s in shapes)
+                s.UpdateBounds();
+
+            // Find perimeter — largest bounding box area
+            var perimeterIndex = 0;
+            var maxArea = shapes[0].BoundingBox.Area();
+            for (var i = 1; i < shapes.Count; i++)
+            {
+                var area = shapes[i].BoundingBox.Area();
+                if (area > maxArea)
+                {
+                    maxArea = area;
+                    perimeterIndex = i;
+                }
+            }
+
+            var result = new List<ContourInfo>();
+            var holeCount = 0;
+            var etchCount = 0;
+            var openCount = 0;
+
+            // Non-perimeter shapes first (matches CNC cut order: holes before perimeter)
+            for (var i = 0; i < shapes.Count; i++)
+            {
+                if (i == perimeterIndex) continue;
+                var shape = shapes[i];
+                var type = ClassifyShape(shape);
+
+                string label;
+                switch (type)
+                {
+                    case ContourClassification.Hole:
+                        holeCount++;
+                        label = $"Hole {holeCount}";
+                        break;
+                    case ContourClassification.Etch:
+                        etchCount++;
+                        label = etchCount == 1 ? "Etch" : $"Etch {etchCount}";
+                        break;
+                    default:
+                        openCount++;
+                        label = openCount == 1 ? "Open" : $"Open {openCount}";
+                        break;
+                }
+
+                result.Add(new ContourInfo(shape, type, label));
+            }
+
+            // Perimeter last
+            result.Add(new ContourInfo(shapes[perimeterIndex], ContourClassification.Perimeter, "Perimeter"));
+
+            return result;
+        }
+
+        private static ContourClassification ClassifyShape(Shape shape)
+        {
+            // Check etch layer — all entities must be on ETCH layer
+            if (shape.Entities.Count > 0 &&
+                shape.Entities.All(e => string.Equals(e.Layer?.Name, "ETCH", StringComparison.OrdinalIgnoreCase)))
+                return ContourClassification.Etch;
+
+            if (shape.IsClosed())
+                return ContourClassification.Hole;
+
+            return ContourClassification.Open;
+        }
+    }
+}

OpenNest.Core/Converters/ConvertGeometry.cs

@@ -97,7 +97,7 @@ namespace OpenNest.Converters
             if (startpt != lastpt)
                 pgm.MoveTo(startpt);
 
-            pgm.ArcTo(startpt, circle.Center, RotationType.CCW);
+            pgm.ArcTo(startpt, circle.Center, circle.Rotation);
 
             lastpt = startpt;
             return lastpt;

OpenNest.Core/Converters/ConvertMode.cs

@@ -1,4 +1,4 @@
-using OpenNest.CNC;
+using OpenNest.CNC;
 using OpenNest.Geometry;
 
 namespace OpenNest.Converters
@@ -9,7 +9,6 @@ namespace OpenNest.Converters
         /// Converts the program to absolute coordinates.
         /// Does NOT check program mode before converting.
         /// </summary>
-        /// <param name="pgm"></param>
         public static void ToAbsolute(Program pgm)
         {
             var pos = new Vector(0, 0);
@@ -17,21 +16,27 @@ namespace OpenNest.Converters
             for (int i = 0; i < pgm.Codes.Count; ++i)
             {
                 var code = pgm.Codes[i];
-                var motion = code as Motion;
 
-                if (motion != null)
+                if (code is SubProgramCall subCall && subCall.Program != null)
                 {
-                    motion.Offset(pos);
+                    // Sub-program is placed at Offset in this program's frame.
+                    // After it runs, the tool is at Offset + (sub's end in its own frame).
+                    pos = ComputeEndPosition(subCall.Program, subCall.Offset);
+                    continue;
+                }
+
+                if (code is Motion motion)
+                {
+                    motion.Offset(pos.X, pos.Y);
                     pos = motion.EndPoint;
                 }
             }
         }
 
         /// <summary>
-        /// Converts the program to intermental coordinates.
+        /// Converts the program to incremental coordinates.
         /// Does NOT check program mode before converting.
         /// </summary>
-        /// <param name="pgm"></param>
         public static void ToIncremental(Program pgm)
         {
             var pos = new Vector(0, 0);
@@ -39,9 +44,16 @@ namespace OpenNest.Converters
             for (int i = 0; i < pgm.Codes.Count; ++i)
             {
                 var code = pgm.Codes[i];
-                var motion = code as Motion;
 
-                if (motion != null)
+                if (code is SubProgramCall subCall && subCall.Program != null)
+                {
+                    // Sub-program is placed at Offset in this program's frame,
+                    // regardless of where the tool was before the call.
+                    pos = ComputeEndPosition(subCall.Program, subCall.Offset);
+                    continue;
+                }
+
+                if (code is Motion motion)
                 {
                     var pos2 = motion.EndPoint;
                     motion.Offset(-pos.X, -pos.Y);
@@ -49,5 +61,37 @@ namespace OpenNest.Converters
                 }
             }
         }
+
+        /// <summary>
+        /// Computes the tool position after executing <paramref name="pgm"/>,
+        /// given that the program's frame origin is at <paramref name="startPos"/>
+        /// in the caller's frame. Walks nested sub-program calls recursively.
+        /// </summary>
+        private static Vector ComputeEndPosition(Program pgm, Vector startPos)
+        {
+            var pos = startPos;
+
+            for (int i = 0; i < pgm.Codes.Count; ++i)
+            {
+                var code = pgm.Codes[i];
+
+                if (code is SubProgramCall subCall && subCall.Program != null)
+                {
+                    // Nested sub's frame origin in the caller's frame is startPos + Offset.
+                    pos = ComputeEndPosition(subCall.Program, startPos + subCall.Offset);
+                    continue;
+                }
+
+                if (code is Motion motion)
+                {
+                    if (pgm.Mode == Mode.Incremental)
+                        pos = pos + motion.EndPoint;
+                    else
+                        pos = startPos + motion.EndPoint;
+                }
+            }
+
+            return pos;
+        }
     }
 }

OpenNest.Core/Converters/ConvertProgram.cs

@@ -20,6 +20,9 @@ namespace OpenNest.Converters
 
         private static void AddProgram(Program program, ref Mode mode, ref Vector curpos, ref List<Entity> geometry)
         {
+            // Capture the frame origin at entry. Sub-program Offsets are relative
+            // to this fixed origin, not to the current tool position.
+            var frameOrigin = curpos;
             mode = program.Mode;
 
             for (int i = 0; i < program.Length; ++i)
@@ -41,12 +44,15 @@ namespace OpenNest.Converters
                         break;
 
                     case CodeType.SubProgramCall:
-                        var tmpmode = mode;
                         var subpgm = (SubProgramCall)code;
-                        var geoProgram = new Shape();
+                        var savedMode = mode;
-                        AddProgram(subpgm.Program, ref mode, ref curpos, ref geoProgram.Entities);
+
-                        geometry.Add(geoProgram);
+                        // The sub-program's frame origin in this program's frame is
-                        mode = tmpmode;
+                        // frameOrigin + Offset — independent of current tool position.
+                        curpos = new Vector(frameOrigin.X + subpgm.Offset.X, frameOrigin.Y + subpgm.Offset.Y);
+
+                        AddProgram(subpgm.Program, ref mode, ref curpos, ref geometry);
+                        mode = savedMode;
                         break;
                 }
             }
@@ -106,7 +112,7 @@ namespace OpenNest.Converters
             var layer = ConvertLayer(arcMove.Layer);
 
             if (startAngle.IsEqualTo(endAngle))
-                geometry.Add(new Circle(center, radius) { Layer = layer, Color = layer.Color });
+                geometry.Add(new Circle(center, radius) { Layer = layer, Color = layer.Color, Rotation = arcMove.Rotation });
             else
                 geometry.Add(new Arc(center, radius, startAngle, endAngle, arcMove.Rotation == RotationType.CW) { Layer = layer, Color = layer.Color });
 

OpenNest.Core/CutOff.cs

@@ -50,13 +50,13 @@ namespace OpenNest
             {
                 cutPosition = Position.X;
                 lineStart = StartLimit ?? bounds.Y;
-                lineEnd = EndLimit ?? (bounds.Y + bounds.Length + settings.Overtravel);
+                lineEnd = EndLimit ?? (bounds.Y + bounds.Width + settings.Overtravel);
             }
             else
             {
                 cutPosition = Position.Y;
                 lineStart = StartLimit ?? bounds.X;
-                lineEnd = EndLimit ?? (bounds.X + bounds.Width + settings.Overtravel);
+                lineEnd = EndLimit ?? (bounds.X + bounds.Length + settings.Overtravel);
             }
 
             var exclusions = new List<(double Start, double End)>();
@@ -176,13 +176,13 @@ namespace OpenNest
 
         private (double Min, double Max) AxisBounds(Box bb, double clearance) =>
             Axis == CutOffAxis.Vertical
-                ? (bb.X - clearance, bb.X + bb.Width + clearance)
+                ? (bb.X - clearance, bb.X + bb.Length + clearance)
-                : (bb.Y - clearance, bb.Y + bb.Length + clearance);
+                : (bb.Y - clearance, bb.Y + bb.Width + clearance);
 
         private (double Start, double End) CrossAxisBounds(Box bb, double clearance) =>
             Axis == CutOffAxis.Vertical
-                ? (bb.Y - clearance, bb.Y + bb.Length + clearance)
+                ? (bb.Y - clearance, bb.Y + bb.Width + clearance)
-                : (bb.X - clearance, bb.X + bb.Width + clearance);
+                : (bb.X - clearance, bb.X + bb.Length + clearance);
 
         private Program BuildProgram(List<(double Start, double End)> segments, CutOffSettings settings)
         {

OpenNest.Core/Drawing.cs

@@ -2,6 +2,7 @@
 using OpenNest.CNC;
 using OpenNest.Converters;
 using OpenNest.Geometry;
+using System;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
@@ -12,8 +13,32 @@ namespace OpenNest
     public class Drawing
     {
         private static int nextId;
+        private static int nextColorIndex;
         private Program program;
 
+        public static readonly Color[] PartColors = new Color[]
+        {
+            Color.FromArgb(205, 92, 92),    // Indian Red
+            Color.FromArgb(148, 103, 189),  // Medium Purple
+            Color.FromArgb(75, 180, 175),   // Teal
+            Color.FromArgb(210, 190, 75),   // Goldenrod
+            Color.FromArgb(190, 85, 175),   // Orchid
+            Color.FromArgb(185, 115, 85),   // Sienna
+            Color.FromArgb(120, 100, 190),  // Slate Blue
+            Color.FromArgb(200, 100, 140),  // Rose
+            Color.FromArgb(80, 175, 155),   // Sea Green
+            Color.FromArgb(195, 160, 85),   // Dark Khaki
+            Color.FromArgb(175, 95, 160),   // Plum
+            Color.FromArgb(215, 130, 130),  // Light Coral
+        };
+
+        public static Color GetNextColor()
+        {
+            var color = PartColors[nextColorIndex % PartColors.Length];
+            nextColorIndex++;
+            return color;
+        }
+
         public Drawing()
             : this(string.Empty, new Program())
         {
@@ -66,6 +91,18 @@ namespace OpenNest
 
         public List<Bend> Bends { get; set; } = new List<Bend>();
 
+        /// <summary>
+        /// Complete set of source entities with stable GUIDs.
+        /// Null when the drawing was created from G-code or an older nest file.
+        /// </summary>
+        public List<Entity> SourceEntities { get; set; }
+
+        /// <summary>
+        /// IDs of entities in <see cref="SourceEntities"/> that are suppressed (hidden).
+        /// Suppressed entities are excluded from the active Program but preserved for re-enabling.
+        /// </summary>
+        public HashSet<Guid> SuppressedEntityIds { get; set; } = new HashSet<Guid>();
+
         public double Area { get; protected set; }
 
         public void UpdateArea()

OpenNest.Core/Geometry/Arc.cs

@@ -155,6 +155,17 @@ namespace OpenNest.Geometry
                 Center.Y + Radius * System.Math.Sin(EndAngle));
         }
 
+        /// <summary>
+        /// Mid point of the arc (point at the angle midway between start and end).
+        /// </summary>
+        public Vector MidPoint()
+        {
+            var midAngle = StartAngle + (IsReversed ? -SweepAngle() / 2 : SweepAngle() / 2);
+            return new Vector(
+                Center.X + Radius * System.Math.Cos(midAngle),
+                Center.Y + Radius * System.Math.Sin(midAngle));
+        }
+
         /// <summary>
         /// Splits the arc at the given point, returning two sub-arcs.
         /// Either half may be null if the split point coincides with an endpoint.
@@ -409,8 +420,8 @@ namespace OpenNest.Geometry
 
             boundingBox.X = minX;
             boundingBox.Y = minY;
-            boundingBox.Width = maxX - minX;
+            boundingBox.Length = maxX - minX;
-            boundingBox.Length = maxY - minY;
+            boundingBox.Width = maxY - minY;
         }
 
         public override Entity OffsetEntity(double distance, OffsetSide side)

OpenNest.Core/Geometry/ArcFit.cs

@@ -56,6 +56,60 @@ namespace OpenNest.Geometry
             return (new Vector(cx, cy), radius, MaxRadialDeviation(points, cx, cy, radius));
         }
 
+        /// <summary>
+        /// Fits a circular arc constrained to be tangent to the given directions at both
+        /// the first and last points. The center lies at the intersection of the normals
+        /// at P1 and Pn, guaranteeing the arc departs P1 in the start direction and arrives
+        /// at Pn in the end direction. Uses the radius from P1 (exact start tangent);
+        /// deviation includes any endpoint gap at Pn.
+        /// </summary>
+        internal static (Vector center, double radius, double deviation) FitWithDualTangent(
+            List<Vector> points, Vector startTangent, Vector endTangent)
+        {
+            if (points.Count < 3)
+                return (Vector.Invalid, 0, double.MaxValue);
+
+            var p1 = points[0];
+            var pn = points[^1];
+
+            var stLen = System.Math.Sqrt(startTangent.X * startTangent.X + startTangent.Y * startTangent.Y);
+            var etLen = System.Math.Sqrt(endTangent.X * endTangent.X + endTangent.Y * endTangent.Y);
+            if (stLen < 1e-10 || etLen < 1e-10)
+                return (Vector.Invalid, 0, double.MaxValue);
+
+            // Normal to start tangent at P1 (perpendicular)
+            var n1x = -startTangent.Y / stLen;
+            var n1y = startTangent.X / stLen;
+
+            // Normal to end tangent at Pn
+            var n2x = -endTangent.Y / etLen;
+            var n2y = endTangent.X / etLen;
+
+            // Solve: P1 + t1*N1 = Pn + t2*N2
+            var det = n1x * (-n2y) - (-n2x) * n1y;
+            if (System.Math.Abs(det) < 1e-10)
+                return (Vector.Invalid, 0, double.MaxValue);
+
+            var dx = pn.X - p1.X;
+            var dy = pn.Y - p1.Y;
+            var t1 = (dx * (-n2y) - (-n2x) * dy) / det;
+
+            var cx = p1.X + t1 * n1x;
+            var cy = p1.Y + t1 * n1y;
+
+            // Use radius from P1 (guarantees exact start tangent and passes through P1)
+            var r1 = System.Math.Sqrt((cx - p1.X) * (cx - p1.X) + (cy - p1.Y) * (cy - p1.Y));
+            if (r1 < 1e-10)
+                return (Vector.Invalid, 0, double.MaxValue);
+
+            // Measure endpoint gap at Pn
+            var r2 = System.Math.Sqrt((cx - pn.X) * (cx - pn.X) + (cy - pn.Y) * (cy - pn.Y));
+            var endpointDev = System.Math.Abs(r2 - r1);
+
+            var interiorDev = MaxRadialDeviation(points, cx, cy, r1);
+            return (new Vector(cx, cy), r1, System.Math.Max(endpointDev, interiorDev));
+        }
+
         /// <summary>
         /// Computes the maximum radial deviation of interior points from a circle.
         /// </summary>

OpenNest.Core/Geometry/BoundingBox.cs

@@ -12,8 +12,8 @@ namespace OpenNest.Geometry
 
             double minX = boxes[0].X;
             double minY = boxes[0].Y;
-            double maxX = boxes[0].X + boxes[0].Width;
+            double maxX = boxes[0].Right;
-            double maxY = boxes[0].Y + boxes[0].Length;
+            double maxY = boxes[0].Top;
 
             foreach (var box in boxes)
             {

OpenNest.Core/Geometry/Box.cs

@@ -14,15 +14,15 @@ namespace OpenNest.Geometry
         public Box(double x, double y, double w, double h)
         {
             Location = new Vector(x, y);
-            Width = w;
+            Length = w;
-            Length = h;
+            Width = h;
         }
 
         public Vector Location;
 
         public Vector Center
         {
-            get { return new Vector(X + Width * 0.5, Y + Length * 0.5); }
+            get { return new Vector(X + Length * 0.5, Y + Width * 0.5); }
         }
 
         public Size Size;
@@ -76,12 +76,12 @@ namespace OpenNest.Geometry
 
         public Box Translate(double x, double y)
         {
-            return new Box(X + x, Y + y, Width, Length);
+            return new Box(X + x, Y + y, Length, Width);
         }
 
         public Box Translate(Vector offset)
         {
-            return new Box(X + offset.X, Y + offset.Y, Width, Length);
+            return new Box(X + offset.X, Y + offset.Y, Length, Width);
         }
 
         public double Left
@@ -91,12 +91,12 @@ namespace OpenNest.Geometry
 
         public double Right
         {
-            get { return X + Width; }
+            get { return X + Length; }
         }
 
         public double Top
         {
-            get { return Y + Length; }
+            get { return Y + Width; }
         }
 
         public double Bottom
@@ -207,7 +207,7 @@ namespace OpenNest.Geometry
 
         public Box Offset(double d)
         {
-            return new Box(X - d, Y - d, Width + d * 2, Length + d * 2);
+            return new Box(X - d, Y - d, Length + d * 2, Width + d * 2);
         }
 
         public override string ToString()

OpenNest.Core/Geometry/BoxSplitter.cs

@@ -9,7 +9,7 @@
 
             var x = large.Left;
             var y = small.Top;
-            var w = large.Width;
+            var w = large.Length;
             var h = large.Top - y;
 
             return new Box(x, y, w, h);
@@ -23,7 +23,7 @@
             var x = large.Left;
             var y = large.Bottom;
             var w = small.Left - x;
-            var h = large.Length;
+            var h = large.Width;
 
             return new Box(x, y, w, h);
         }
@@ -35,7 +35,7 @@
 
             var x = large.Left;
             var y = large.Bottom;
-            var w = large.Width;
+            var w = large.Length;
             var h = small.Top - y;
 
             return new Box(x, y, w, h);
@@ -49,7 +49,7 @@
             var x = small.Right;
             var y = large.Bottom;
             var w = large.Right - x;
-            var h = large.Length;
+            var h = large.Width;
 
             return new Box(x, y, w, h);
         }

OpenNest.Core/Geometry/Circle.cs

@@ -137,7 +137,9 @@ namespace OpenNest.Geometry
         public List<Vector> ToPoints(int segments = 1000, bool circumscribe = false)
         {
             var points = new List<Vector>();
-            var stepAngle = Angle.TwoPI / segments;
+            var stepAngle = Rotation == RotationType.CW
+                ? -Angle.TwoPI / segments
+                : Angle.TwoPI / segments;
 
             var r = circumscribe && segments > 0
                 ? Radius / System.Math.Cos(stepAngle / 2.0)

OpenNest.Core/Geometry/Entity.cs

@@ -1,4 +1,5 @@
 using OpenNest.Math;
+using System;
 using System.Collections.Generic;
 using System.Drawing;
 
@@ -10,10 +11,16 @@ namespace OpenNest.Geometry
 
         protected Entity()
         {
+            Id = Guid.NewGuid();
             Layer = OpenNest.Geometry.Layer.Default;
             boundingBox = new Box();
         }
 
+        /// <summary>
+        /// Unique identifier for this entity, stable across edit sessions.
+        /// </summary>
+        public Guid Id { get; set; }
+
         /// <summary>
         /// Entity color (resolved from DXF ByLayer/ByBlock to actual color).
         /// </summary>

OpenNest.Core/Geometry/GeometrySimplifier.cs

@@ -134,13 +134,11 @@ public class GeometrySimplifier
 
         if (midpoints.Count < 4) return MirrorAxisResult.None;
 
-        // Centroid
+        var centroid = new Vector(
-        var cx = 0.0;
+            midpoints.Average(p => p.X),
-        var cy = 0.0;
+            midpoints.Average(p => p.Y));
-        foreach (var p in midpoints) { cx += p.X; cy += p.Y; }
+        var cx = centroid.X;
-        cx /= midpoints.Count;
+        var cy = centroid.Y;
-        cy /= midpoints.Count;
-        var centroid = new Vector(cx, cy);
 
         // Covariance matrix for PCA
         var cxx = 0.0;
@@ -192,12 +190,25 @@ public class GeometrySimplifier
         return bestResult.Score >= 0.8 ? bestResult : MirrorAxisResult.None;
     }
 
+    private static double NormalizeAngle(double angle) =>
+        angle < 0 ? angle + Angle.TwoPI : angle;
+
     private static Vector Normalize(Vector v)
     {
         var len = System.Math.Sqrt(v.X * v.X + v.Y * v.Y);
         return len < 1e-10 ? new Vector(1, 0) : new Vector(v.X / len, v.Y / len);
     }
 
+    private static double PerpendicularDistance(Vector point, Vector axisPoint, Vector axisDir)
+    {
+        var dx = point.X - axisPoint.X;
+        var dy = point.Y - axisPoint.Y;
+        var dot = dx * axisDir.X + dy * axisDir.Y;
+        var px = dx - dot * axisDir.X;
+        var py = dy - dot * axisDir.Y;
+        return System.Math.Sqrt(px * px + py * py);
+    }
+
     private static double MirrorMatchScore(List<Vector> points, Vector axisPoint, Vector axisDir)
     {
         var matchTol = 0.1;
@@ -206,14 +217,7 @@ public class GeometrySimplifier
         for (var i = 0; i < points.Count; i++)
         {
             var p = points[i];
-
+            var dist = PerpendicularDistance(p, axisPoint, axisDir);
-            // Distance from point to axis
-            var dx = p.X - axisPoint.X;
-            var dy = p.Y - axisPoint.Y;
-            var dot = dx * axisDir.X + dy * axisDir.Y;
-            var perpX = dx - dot * axisDir.X;
-            var perpY = dy - dot * axisDir.Y;
-            var dist = System.Math.Sqrt(perpX * perpX + perpY * perpY);
 
             // Points on the axis count as matched
             if (dist < matchTol)
@@ -223,14 +227,12 @@ public class GeometrySimplifier
             }
 
             // Reflect across axis and look for partner
-            var mx = p.X - 2 * perpX;
+            var reflected = new MirrorAxisResult(axisPoint, axisDir, 0).Reflect(p);
-            var my = p.Y - 2 * perpY;
 
             for (var j = 0; j < points.Count; j++)
             {
                 if (i == j) continue;
-                var d = System.Math.Sqrt((points[j].X - mx) * (points[j].X - mx) +
+                var d = reflected.DistanceTo(points[j]);
-                                         (points[j].Y - my) * (points[j].Y - my));
                 if (d < matchTol)
                 {
                     matched++;
@@ -259,14 +261,7 @@ public class GeometrySimplifier
 
             var ci = candidates[i];
             var ciCenter = ci.BoundingBox.Center;
-
+            if (PerpendicularDistance(ciCenter, axis.Point, axis.Direction) < 0.1) continue; // on the axis
-            // Distance from candidate center to axis
-            var dx = ciCenter.X - axis.Point.X;
-            var dy = ciCenter.Y - axis.Point.Y;
-            var dot = dx * axis.Direction.X + dy * axis.Direction.Y;
-            var perpDist = System.Math.Sqrt((dx - dot * axis.Direction.X) * (dx - dot * axis.Direction.X) +
-                                            (dy - dot * axis.Direction.Y) * (dy - dot * axis.Direction.Y));
-            if (perpDist < 0.1) continue; // on the axis
 
             var mirrorCenter = axis.Reflect(ciCenter);
 
@@ -328,12 +323,8 @@ public class GeometrySimplifier
         var mirrorEp = axis.Reflect(ep);
 
         // Mirroring reverses winding — swap start/end to preserve arc direction
-        var mirrorStart = System.Math.Atan2(mirrorEp.Y - mirrorCenter.Y, mirrorEp.X - mirrorCenter.X);
+        var mirrorStart = NormalizeAngle(System.Math.Atan2(mirrorEp.Y - mirrorCenter.Y, mirrorEp.X - mirrorCenter.X));
-        var mirrorEnd = System.Math.Atan2(mirrorSp.Y - mirrorCenter.Y, mirrorSp.X - mirrorCenter.X);
+        var mirrorEnd = NormalizeAngle(System.Math.Atan2(mirrorSp.Y - mirrorCenter.Y, mirrorSp.X - mirrorCenter.X));
-
-        // Normalize to [0, 2pi)
-        if (mirrorStart < 0) mirrorStart += Angle.TwoPI;
-        if (mirrorEnd < 0) mirrorEnd += Angle.TwoPI;
 
         var result = new Arc(mirrorCenter, arc.Radius, mirrorStart, mirrorEnd, arc.IsReversed);
         result.Layer = arc.Layer;
@@ -357,15 +348,16 @@ public class GeometrySimplifier
             }
 
             chainedTangent = ComputeEndTangent(result.Center, result.Points);
+            var arc = CreateArc(result.Center, result.Radius, result.Points, entities[j]);
             candidates.Add(new ArcCandidate
             {
                 StartIndex = j,
                 EndIndex = result.EndIndex,
-                FittedArc = CreateArc(result.Center, result.Radius, result.Points, entities[j]),
+                FittedArc = arc,
                 MaxDeviation = result.Deviation,
                 BoundingBox = result.Points.GetBoundingBox(),
-                FirstPoint = result.Points[0],
+                FirstPoint = arc.StartPoint(),
-                LastPoint = result.Points[^1],
+                LastPoint = arc.EndPoint(),
             });
 
             j = result.EndIndex + 1;
@@ -386,14 +378,16 @@ public class GeometrySimplifier
             ? chainedTangent
             : new Vector(points[1].X - points[0].X, points[1].Y - points[0].Y);
 
-        var (center, radius, dev) = TryFit(points, startTangent);
+        var endTangent = GetExitDirection(entities[k]);
+        var (center, radius, dev) = TryFit(points, startTangent, endTangent);
         if (!center.IsValid()) return null;
 
         // Extend the arc as far as possible
         while (k + 1 <= runEnd)
         {
             var extPoints = CollectPoints(entities, start, k + 1);
-            var (nc, nr, nd) = extPoints.Count >= 3 ? TryFit(extPoints, startTangent) : (Vector.Invalid, 0, 0d);
+            var extEndTangent = GetExitDirection(entities[k + 1]);
+            var (nc, nr, nd) = extPoints.Count >= 3 ? TryFit(extPoints, startTangent, extEndTangent) : (Vector.Invalid, 0, 0d);
             if (!nc.IsValid()) break;
 
             k++;
@@ -413,9 +407,23 @@ public class GeometrySimplifier
         return new ArcFitResult(center, radius, dev, points, k);
     }
 
-    private (Vector center, double radius, double deviation) TryFit(List<Vector> points, Vector startTangent)
+    private (Vector center, double radius, double deviation) TryFit(List<Vector> points, Vector startTangent, Vector endTangent)
     {
-        var (center, radius, dev) = FitWithStartTangent(points, startTangent);
+        // Try dual-tangent fit first (matches direction at both endpoints)
+        if (endTangent.IsValid())
+        {
+            var (dc, dr, dd) = ArcFit.FitWithDualTangent(points, startTangent, endTangent);
+            if (dc.IsValid() && dd <= Tolerance)
+            {
+                var isRev = SumSignedAngles(dc, points) < 0;
+                var aDev = MaxArcToSegmentDeviation(points, dc, dr, isRev);
+                if (aDev <= Tolerance)
+                    return (dc, dr, System.Math.Max(dd, aDev));
+            }
+        }
+
+        // Fall back to start-tangent-only, then mirror axis
+        var (center, radius, dev) = ArcFit.FitWithStartTangent(points, startTangent);
         if (!center.IsValid() || dev > Tolerance)
             (center, radius, dev) = FitMirrorAxis(points);
         if (!center.IsValid() || dev > Tolerance)
@@ -430,16 +438,6 @@ public class GeometrySimplifier
         return (center, radius, System.Math.Max(dev, arcDev));
     }
 
-    /// <summary>
-    /// Fits a circular arc constrained to be tangent to the given direction at the
-    /// first point. The center lies at the intersection of the normal at P1 (perpendicular
-    /// to the tangent) and the perpendicular bisector of the chord P1->Pn, guaranteeing
-    /// the arc passes through both endpoints and departs P1 in the given direction.
-    /// </summary>
-    private static (Vector center, double radius, double deviation) FitWithStartTangent(
-        List<Vector> points, Vector tangent) =>
-        ArcFit.FitWithStartTangent(points, tangent);
-
     /// <summary>
     /// Computes the tangent direction at the last point of a fitted arc,
     /// used to chain tangent continuity to the next arc.
@@ -447,15 +445,10 @@ public class GeometrySimplifier
     private static Vector ComputeEndTangent(Vector center, List<Vector> points)
     {
         var lastPt = points[^1];
-        var totalAngle = SumSignedAngles(center, points);
-
         var rx = lastPt.X - center.X;
         var ry = lastPt.Y - center.Y;
-
+        var sign = SumSignedAngles(center, points) >= 0 ? 1 : -1;
-        if (totalAngle >= 0)
+        return new Vector(-sign * ry, sign * rx);
-            return new Vector(-ry, rx);
-        else
-            return new Vector(ry, -rx);
     }
 
     /// <summary>
@@ -496,12 +489,12 @@ public class GeometrySimplifier
         var range = System.Math.Max(System.Math.Abs(dInit) * 2, halfChord);
 
         var dOpt = GoldenSectionMin(dInit - range, dInit + range,
-            d => MaxRadialDeviation(points, mx + d * nx, my + d * ny,
+            d => ArcFit.MaxRadialDeviation(points, mx + d * nx, my + d * ny,
                 System.Math.Sqrt(halfChord * halfChord + d * d)));
 
         var center = new Vector(mx + dOpt * nx, my + dOpt * ny);
         var radius = System.Math.Sqrt(halfChord * halfChord + dOpt * dOpt);
-        return (center, radius, MaxRadialDeviation(points, center.X, center.Y, radius));
+        return (center, radius, ArcFit.MaxRadialDeviation(points, center.X, center.Y, radius));
     }
 
     private static double GoldenSectionMin(double low, double high, Func<double, double> eval)
@@ -554,20 +547,28 @@ public class GeometrySimplifier
         var firstPoint = points[0];
         var lastPoint = points[^1];
 
-        var startAngle = System.Math.Atan2(firstPoint.Y - center.Y, firstPoint.X - center.X);
+        var startAngle = NormalizeAngle(System.Math.Atan2(firstPoint.Y - center.Y, firstPoint.X - center.X));
-        var endAngle = System.Math.Atan2(lastPoint.Y - center.Y, lastPoint.X - center.X);
+        var endAngle = NormalizeAngle(System.Math.Atan2(lastPoint.Y - center.Y, lastPoint.X - center.X));
         var isReversed = SumSignedAngles(center, points) < 0;
 
-        // Normalize to [0, 2pi)
-        if (startAngle < 0) startAngle += Angle.TwoPI;
-        if (endAngle < 0) endAngle += Angle.TwoPI;
-
         var arc = new Arc(center, radius, startAngle, endAngle, isReversed);
         arc.Layer = sourceEntity.Layer;
         arc.Color = sourceEntity.Color;
         return arc;
     }
 
+    /// <summary>
+    /// Returns the exit direction (tangent at endpoint) of an entity.
+    /// </summary>
+    private static Vector GetExitDirection(Entity entity) => entity switch
+    {
+        Line line => new Vector(line.EndPoint.X - line.StartPoint.X, line.EndPoint.Y - line.StartPoint.Y),
+        Arc arc => arc.IsReversed
+            ? new Vector(System.Math.Sin(arc.EndAngle), -System.Math.Cos(arc.EndAngle))
+            : new Vector(-System.Math.Sin(arc.EndAngle), System.Math.Cos(arc.EndAngle)),
+        _ => Vector.Invalid,
+    };
+
     /// <summary>
     /// Sums signed angular change traversing consecutive points around a center.
     /// Positive = CCW, negative = CW.
@@ -587,12 +588,6 @@ public class GeometrySimplifier
         return total;
     }
 
-    /// <summary>
-    /// Max deviation of intermediate points (excluding endpoints) from a circle.
-    /// </summary>
-    private static double MaxRadialDeviation(List<Vector> points, double cx, double cy, double radius) =>
-        ArcFit.MaxRadialDeviation(points, cx, cy, radius);
-
     /// <summary>
     /// Measures the maximum distance from sampled points along the fitted arc
     /// back to the original line segments. This catches cases where points lie

OpenNest.Core/Geometry/Line.cs

@@ -370,23 +370,23 @@ namespace OpenNest.Geometry
             if (StartPoint.X < EndPoint.X)
             {
                 boundingBox.X = StartPoint.X;
-                boundingBox.Width = EndPoint.X - StartPoint.X;
+                boundingBox.Length = EndPoint.X - StartPoint.X;
             }
             else
             {
                 boundingBox.X = EndPoint.X;
-                boundingBox.Width = StartPoint.X - EndPoint.X;
+                boundingBox.Length = StartPoint.X - EndPoint.X;
             }
 
             if (StartPoint.Y < EndPoint.Y)
             {
                 boundingBox.Y = StartPoint.Y;
-                boundingBox.Length = EndPoint.Y - StartPoint.Y;
+                boundingBox.Width = EndPoint.Y - StartPoint.Y;
             }
             else
             {
                 boundingBox.Y = EndPoint.Y;
-                boundingBox.Length = StartPoint.Y - EndPoint.Y;
+                boundingBox.Width = StartPoint.Y - EndPoint.Y;
             }
         }
 

OpenNest.Core/Geometry/Polygon.cs

@@ -311,8 +311,8 @@ namespace OpenNest.Geometry
 
             boundingBox.X = minX;
             boundingBox.Y = minY;
-            boundingBox.Width = maxX - minX;
+            boundingBox.Length = maxX - minX;
-            boundingBox.Length = maxY - minY;
+            boundingBox.Width = maxY - minY;
         }
 
         public override Entity OffsetEntity(double distance, OffsetSide side)

OpenNest.Core/Geometry/Shape.cs

@@ -605,7 +605,7 @@ namespace OpenNest.Geometry
                         copy.Entities.Add(new Arc(a.Center, a.Radius, a.EndAngle, a.StartAngle, !a.IsReversed) { Layer = a.Layer });
                         break;
                     case Circle c:
-                        copy.Entities.Add(new Circle(c.Center, c.Radius) { Layer = c.Layer });
+                        copy.Entities.Add(new Circle(c.Center, c.Radius) { Layer = c.Layer, Rotation = RotationType.CW });
                         break;
                 }
             }
@@ -640,7 +640,7 @@ namespace OpenNest.Geometry
                         copy.Entities.Add(new Arc(a.Center, a.Radius, a.EndAngle, a.StartAngle, !a.IsReversed) { Layer = a.Layer });
                         break;
                     case Circle c:
-                        copy.Entities.Add(new Circle(c.Center, c.Radius) { Layer = c.Layer });
+                        copy.Entities.Add(new Circle(c.Center, c.Radius) { Layer = c.Layer, Rotation = RotationType.CCW });
                         break;
                 }
             }

OpenNest.Core/Geometry/SpatialQuery.cs

@@ -104,6 +104,98 @@ namespace OpenNest.Geometry
             return double.MaxValue;
         }
 
+        /// <summary>
+        /// Solves ray-circle intersection, returning the two parametric t values.
+        /// Returns false if no real intersection exists.
+        /// </summary>
+        [System.Runtime.CompilerServices.MethodImpl(
+            System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static bool SolveRayCircle(
+            double vx, double vy,
+            double cx, double cy, double r,
+            double dirX, double dirY,
+            out double t1, out double t2)
+        {
+            var ox = vx - cx;
+            var oy = vy - cy;
+
+            var a = dirX * dirX + dirY * dirY;
+            var b = 2.0 * (ox * dirX + oy * dirY);
+            var c = ox * ox + oy * oy - r * r;
+
+            var discriminant = b * b - 4.0 * a * c;
+            if (discriminant < 0)
+            {
+                t1 = t2 = double.MaxValue;
+                return false;
+            }
+
+            var sqrtD = System.Math.Sqrt(discriminant);
+            var inv2a = 1.0 / (2.0 * a);
+            t1 = (-b - sqrtD) * inv2a;
+            t2 = (-b + sqrtD) * inv2a;
+            return true;
+        }
+
+        /// <summary>
+        /// Computes the distance from a point along a direction to an arc.
+        /// Solves ray-circle intersection, then constrains hits to the arc's
+        /// angular span. Returns double.MaxValue if no hit.
+        /// </summary>
+        [System.Runtime.CompilerServices.MethodImpl(
+            System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static double RayArcDistance(
+            double vx, double vy,
+            double cx, double cy, double r,
+            double startAngle, double endAngle, bool reversed,
+            double dirX, double dirY)
+        {
+            if (!SolveRayCircle(vx, vy, cx, cy, r, dirX, dirY, out var t1, out var t2))
+                return double.MaxValue;
+
+            var best = double.MaxValue;
+
+            if (t1 > -Tolerance.Epsilon)
+            {
+                var hitAngle = Angle.NormalizeRad(System.Math.Atan2(
+                    vy + t1 * dirY - cy, vx + t1 * dirX - cx));
+                if (Angle.IsBetweenRad(hitAngle, startAngle, endAngle, reversed))
+                    best = t1 > Tolerance.Epsilon ? t1 : 0;
+            }
+
+            if (t2 > -Tolerance.Epsilon && t2 < best)
+            {
+                var hitAngle = Angle.NormalizeRad(System.Math.Atan2(
+                    vy + t2 * dirY - cy, vx + t2 * dirX - cx));
+                if (Angle.IsBetweenRad(hitAngle, startAngle, endAngle, reversed))
+                    best = t2 > Tolerance.Epsilon ? t2 : 0;
+            }
+
+            return best;
+        }
+
+        /// <summary>
+        /// Computes the distance from a point along a direction to a full circle.
+        /// Returns double.MaxValue if no hit.
+        /// </summary>
+        [System.Runtime.CompilerServices.MethodImpl(
+            System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static double RayCircleDistance(
+            double vx, double vy,
+            double cx, double cy, double r,
+            double dirX, double dirY)
+        {
+            if (!SolveRayCircle(vx, vy, cx, cy, r, dirX, dirY, out var t1, out var t2))
+                return double.MaxValue;
+
+            if (t1 > Tolerance.Epsilon) return t1;
+            if (t1 >= -Tolerance.Epsilon) return 0;
+            if (t2 > Tolerance.Epsilon) return t2;
+            if (t2 >= -Tolerance.Epsilon) return 0;
+
+            return double.MaxValue;
+        }
+
         /// <summary>
         /// Computes the minimum translation distance along a push direction before
         /// any edge of movingLines contacts any edge of stationaryLines.
@@ -111,57 +203,7 @@ namespace OpenNest.Geometry
         /// </summary>
         public static double DirectionalDistance(List<Line> movingLines, List<Line> stationaryLines, PushDirection direction)
         {
-            var minDist = double.MaxValue;
+            return DirectionalDistance(movingLines, 0, 0, stationaryLines, direction);
-
-            // Case 1: Each moving vertex -> each stationary edge
-            var movingVertices = new HashSet<Vector>();
-            for (int i = 0; i < movingLines.Count; i++)
-            {
-                movingVertices.Add(movingLines[i].pt1);
-                movingVertices.Add(movingLines[i].pt2);
-            }
-
-            var stationaryEdges = new (Vector start, Vector end)[stationaryLines.Count];
-            for (int i = 0; i < stationaryLines.Count; i++)
-                stationaryEdges[i] = (stationaryLines[i].pt1, stationaryLines[i].pt2);
-
-            // Sort edges for pruning if not already sorted (usually they aren't here)
-            if (direction == PushDirection.Left || direction == PushDirection.Right)
-                stationaryEdges = stationaryEdges.OrderBy(e => System.Math.Min(e.start.Y, e.end.Y)).ToArray();
-            else
-                stationaryEdges = stationaryEdges.OrderBy(e => System.Math.Min(e.start.X, e.end.X)).ToArray();
-
-            foreach (var mv in movingVertices)
-            {
-                var d = OneWayDistance(mv, stationaryEdges, Vector.Zero, direction);
-                if (d < minDist) minDist = d;
-            }
-
-            // Case 2: Each stationary vertex -> each moving edge (opposite direction)
-            var opposite = OppositeDirection(direction);
-            var stationaryVertices = new HashSet<Vector>();
-            for (int i = 0; i < stationaryLines.Count; i++)
-            {
-                stationaryVertices.Add(stationaryLines[i].pt1);
-                stationaryVertices.Add(stationaryLines[i].pt2);
-            }
-
-            var movingEdges = new (Vector start, Vector end)[movingLines.Count];
-            for (int i = 0; i < movingLines.Count; i++)
-                movingEdges[i] = (movingLines[i].pt1, movingLines[i].pt2);
-
-            if (opposite == PushDirection.Left || opposite == PushDirection.Right)
-                movingEdges = movingEdges.OrderBy(e => System.Math.Min(e.start.Y, e.end.Y)).ToArray();
-            else
-                movingEdges = movingEdges.OrderBy(e => System.Math.Min(e.start.X, e.end.X)).ToArray();
-
-            foreach (var sv in stationaryVertices)
-            {
-                var d = OneWayDistance(sv, movingEdges, Vector.Zero, opposite);
-                if (d < minDist) minDist = d;
-            }
-
-            return minDist;
         }
 
         /// <summary>
@@ -176,21 +218,10 @@ namespace OpenNest.Geometry
             var movingOffset = new Vector(movingDx, movingDy);
 
             // Case 1: Each moving vertex -> each stationary edge
-            var movingVertices = new HashSet<Vector>();
+            var movingVertices = CollectVertices(movingLines, movingOffset);
-            for (int i = 0; i < movingLines.Count; i++)
-            {
-                movingVertices.Add(movingLines[i].pt1 + movingOffset);
-                movingVertices.Add(movingLines[i].pt2 + movingOffset);
-            }
 
-            var stationaryEdges = new (Vector start, Vector end)[stationaryLines.Count];
+            var stationaryEdges = ToEdgeArray(stationaryLines);
-            for (int i = 0; i < stationaryLines.Count; i++)
+            SortEdgesForPruning(stationaryEdges, direction);
-                stationaryEdges[i] = (stationaryLines[i].pt1, stationaryLines[i].pt2);
-
-            if (direction == PushDirection.Left || direction == PushDirection.Right)
-                stationaryEdges = stationaryEdges.OrderBy(e => System.Math.Min(e.start.Y, e.end.Y)).ToArray();
-            else
-                stationaryEdges = stationaryEdges.OrderBy(e => System.Math.Min(e.start.X, e.end.X)).ToArray();
 
             foreach (var mv in movingVertices)
             {
@@ -200,21 +231,10 @@ namespace OpenNest.Geometry
 
             // Case 2: Each stationary vertex -> each moving edge (opposite direction)
             var opposite = OppositeDirection(direction);
-            var stationaryVertices = new HashSet<Vector>();
+            var stationaryVertices = CollectVertices(stationaryLines, Vector.Zero);
-            for (int i = 0; i < stationaryLines.Count; i++)
-            {
-                stationaryVertices.Add(stationaryLines[i].pt1);
-                stationaryVertices.Add(stationaryLines[i].pt2);
-            }
 
-            var movingEdges = new (Vector start, Vector end)[movingLines.Count];
+            var movingEdges = ToEdgeArray(movingLines);
-            for (int i = 0; i < movingLines.Count; i++)
+            SortEdgesForPruning(movingEdges, opposite);
-                movingEdges[i] = (movingLines[i].pt1, movingLines[i].pt2);
-
-            if (opposite == PushDirection.Left || opposite == PushDirection.Right)
-                movingEdges = movingEdges.OrderBy(e => System.Math.Min(e.start.Y, e.end.Y)).ToArray();
-            else
-                movingEdges = movingEdges.OrderBy(e => System.Math.Min(e.start.X, e.end.X)).ToArray();
 
             foreach (var sv in stationaryVertices)
             {
@@ -253,15 +273,11 @@ namespace OpenNest.Geometry
         {
             var minDist = double.MaxValue;
 
-            // Extract unique vertices from moving edges.
+            SortEdgesForPruning(stationaryEdges, direction);
-            var movingVertices = new HashSet<Vector>();
-            for (var i = 0; i < movingEdges.Length; i++)
-            {
-                movingVertices.Add(movingEdges[i].start + movingOffset);
-                movingVertices.Add(movingEdges[i].end + movingOffset);
-            }
 
             // Case 1: Each moving vertex -> each stationary edge
+            var movingVertices = CollectVertices(movingEdges, movingOffset);
+
             foreach (var mv in movingVertices)
             {
                 var d = OneWayDistance(mv, stationaryEdges, stationaryOffset, direction);
@@ -270,12 +286,9 @@ namespace OpenNest.Geometry
 
             // Case 2: Each stationary vertex -> each moving edge (opposite direction)
             var opposite = OppositeDirection(direction);
-            var stationaryVertices = new HashSet<Vector>();
+            SortEdgesForPruning(movingEdges, opposite);
-            for (var i = 0; i < stationaryEdges.Length; i++)
+
-            {
+            var stationaryVertices = CollectVertices(stationaryEdges, stationaryOffset);
-                stationaryVertices.Add(stationaryEdges[i].start + stationaryOffset);
-                stationaryVertices.Add(stationaryEdges[i].end + stationaryOffset);
-            }
 
             foreach (var sv in stationaryVertices)
             {
@@ -467,12 +480,7 @@ namespace OpenNest.Geometry
             var dirX = direction.X;
             var dirY = direction.Y;
 
-            var movingVertices = new HashSet<Vector>();
+            var movingVertices = CollectVertices(movingLines, Vector.Zero);
-            for (var i = 0; i < movingLines.Count; i++)
-            {
-                movingVertices.Add(movingLines[i].pt1);
-                movingVertices.Add(movingLines[i].pt2);
-            }
 
             foreach (var mv in movingVertices)
             {
@@ -487,12 +495,7 @@ namespace OpenNest.Geometry
             var oppX = -dirX;
             var oppY = -dirY;
 
-            var stationaryVertices = new HashSet<Vector>();
+            var stationaryVertices = CollectVertices(stationaryLines, Vector.Zero);
-            for (var i = 0; i < stationaryLines.Count; i++)
-            {
-                stationaryVertices.Add(stationaryLines[i].pt1);
-                stationaryVertices.Add(stationaryLines[i].pt2);
-            }
 
             foreach (var sv in stationaryVertices)
             {
@@ -507,6 +510,284 @@ namespace OpenNest.Geometry
             return minDist;
         }
 
+        /// <summary>
+        /// Computes the minimum translation distance along a push direction
+        /// before any vertex/edge of movingEntities contacts any vertex/edge of
+        /// stationaryEntities. Delegates to the Vector-based overload.
+        /// </summary>
+        public static double DirectionalDistance(
+            List<Entity> movingEntities, List<Entity> stationaryEntities, PushDirection direction)
+        {
+            return DirectionalDistance(movingEntities, stationaryEntities, DirectionToOffset(direction, 1.0));
+        }
+
+        /// <summary>
+        /// Computes the minimum translation distance along an arbitrary unit direction
+        /// before any vertex/edge of movingEntities contacts any vertex/edge of
+        /// stationaryEntities. Works with native Line, Arc, and Circle entities
+        /// without tessellation.
+        /// </summary>
+        public static double DirectionalDistance(
+            List<Entity> movingEntities, List<Entity> stationaryEntities, Vector direction)
+        {
+            var minDist = double.MaxValue;
+            var dirX = direction.X;
+            var dirY = direction.Y;
+
+            var movingVertices = ExtractEntityVertices(movingEntities);
+
+            for (var v = 0; v < movingVertices.Length; v++)
+            {
+                var vx = movingVertices[v].X;
+                var vy = movingVertices[v].Y;
+
+                for (var j = 0; j < stationaryEntities.Count; j++)
+                {
+                    var d = RayEntityDistance(vx, vy, stationaryEntities[j], dirX, dirY);
+                    if (d < minDist)
+                    {
+                        minDist = d;
+                        if (d <= 0) return 0;
+                    }
+                }
+            }
+
+            var oppX = -dirX;
+            var oppY = -dirY;
+
+            var stationaryVertices = ExtractEntityVertices(stationaryEntities);
+
+            for (var v = 0; v < stationaryVertices.Length; v++)
+            {
+                var vx = stationaryVertices[v].X;
+                var vy = stationaryVertices[v].Y;
+
+                for (var j = 0; j < movingEntities.Count; j++)
+                {
+                    var d = RayEntityDistance(vx, vy, movingEntities[j], oppX, oppY);
+                    if (d < minDist)
+                    {
+                        minDist = d;
+                        if (d <= 0) return 0;
+                    }
+                }
+            }
+
+            // Phase 3: Arc-to-line closest-point check.
+            // Phases 1-2 sample arc endpoints and cardinal extremes, but the actual
+            // closest point on a small corner arc to a straight edge may lie between
+            // those samples. Use ClosestPointTo to find it and fire a ray from there.
+            minDist = ArcToLineClosestDistance(movingEntities, stationaryEntities, dirX, dirY, minDist);
+            if (minDist <= 0) return 0;
+            minDist = ArcToLineClosestDistance(stationaryEntities, movingEntities, oppX, oppY, minDist);
+            if (minDist <= 0) return 0;
+
+            // Phase 4: Curve-to-curve direct distance.
+            // The vertex-to-entity approach misses the closest contact between two
+            // curved entities (circles/arcs) because only a few cardinal vertices are
+            // sampled. The true closest contact along the push direction is found by
+            // treating it as a ray from one center to an expanded circle at the other
+            // center (radius = r1 + r2).
+            for (var i = 0; i < movingEntities.Count; i++)
+            {
+                var me = movingEntities[i];
+                if (!TryGetCurveParams(me, out var mcx, out var mcy, out var mr))
+                    continue;
+
+                for (var j = 0; j < stationaryEntities.Count; j++)
+                {
+                    var se = stationaryEntities[j];
+                    if (!TryGetCurveParams(se, out var scx, out var scy, out var sr))
+                        continue;
+
+                    var d = RayCircleDistance(mcx, mcy, scx, scy, mr + sr, dirX, dirY);
+
+                    if (d >= minDist)
+                        continue;
+
+                    // For arcs, verify the contact point falls within both arcs' angular ranges.
+                    if (me is Arc || se is Arc)
+                    {
+                        var mx = mcx + d * dirX;
+                        var my = mcy + d * dirY;
+                        var toCx = scx - mx;
+                        var toCy = scy - my;
+
+                        if (me is Arc mArc)
+                        {
+                            var angle = Angle.NormalizeRad(System.Math.Atan2(toCy, toCx));
+                            if (!Angle.IsBetweenRad(angle, mArc.StartAngle, mArc.EndAngle, mArc.IsReversed))
+                                continue;
+                        }
+
+                        if (se is Arc sArc)
+                        {
+                            var angle = Angle.NormalizeRad(System.Math.Atan2(-toCy, -toCx));
+                            if (!Angle.IsBetweenRad(angle, sArc.StartAngle, sArc.EndAngle, sArc.IsReversed))
+                                continue;
+                        }
+                    }
+
+                    minDist = d;
+                    if (d <= 0) return 0;
+                }
+            }
+
+            return minDist;
+        }
+
+        private static double ArcToLineClosestDistance(
+            List<Entity> arcEntities, List<Entity> lineEntities,
+            double dirX, double dirY, double minDist)
+        {
+            for (var i = 0; i < arcEntities.Count; i++)
+            {
+                if (arcEntities[i] is Arc arc)
+                {
+                    for (var j = 0; j < lineEntities.Count; j++)
+                    {
+                        if (lineEntities[j] is Line line)
+                        {
+                            var linePt = line.ClosestPointTo(arc.Center);
+                            var arcPt = arc.ClosestPointTo(linePt);
+                            var d = RayEdgeDistance(arcPt.X, arcPt.Y,
+                                line.pt1.X, line.pt1.Y, line.pt2.X, line.pt2.Y,
+                                dirX, dirY);
+                            if (d < minDist) { minDist = d; if (d <= 0) return 0; }
+                        }
+                    }
+                }
+            }
+            return minDist;
+        }
+
+        private static double RayEntityDistance(
+            double vx, double vy, Entity entity, double dirX, double dirY)
+        {
+            if (entity is Line line)
+            {
+                return RayEdgeDistance(vx, vy,
+                    line.pt1.X, line.pt1.Y, line.pt2.X, line.pt2.Y,
+                    dirX, dirY);
+            }
+
+            if (entity is Arc arc)
+            {
+                return RayArcDistance(vx, vy,
+                    arc.Center.X, arc.Center.Y, arc.Radius,
+                    arc.StartAngle, arc.EndAngle, arc.IsReversed,
+                    dirX, dirY);
+            }
+
+            if (entity is Circle circle)
+            {
+                return RayCircleDistance(vx, vy,
+                    circle.Center.X, circle.Center.Y, circle.Radius,
+                    dirX, dirY);
+            }
+
+            return double.MaxValue;
+        }
+
+        private static Vector[] ExtractEntityVertices(List<Entity> entities)
+        {
+            var vertices = new HashSet<Vector>();
+
+            for (var i = 0; i < entities.Count; i++)
+            {
+                var entity = entities[i];
+
+                if (entity is Line line)
+                {
+                    vertices.Add(line.pt1);
+                    vertices.Add(line.pt2);
+                }
+                else if (entity is Arc arc)
+                {
+                    vertices.Add(arc.StartPoint());
+                    vertices.Add(arc.EndPoint());
+                    AddArcExtremeVertices(vertices, arc);
+                }
+                else if (entity is Circle circle)
+                {
+                    vertices.Add(new Vector(circle.Center.X + circle.Radius, circle.Center.Y));
+                    vertices.Add(new Vector(circle.Center.X - circle.Radius, circle.Center.Y));
+                    vertices.Add(new Vector(circle.Center.X, circle.Center.Y + circle.Radius));
+                    vertices.Add(new Vector(circle.Center.X, circle.Center.Y - circle.Radius));
+                }
+            }
+
+            return vertices.ToArray();
+        }
+
+        private static void AddArcExtremeVertices(HashSet<Vector> points, Arc arc)
+        {
+            var a1 = arc.StartAngle;
+            var a2 = arc.EndAngle;
+
+            if (arc.IsReversed)
+                Generic.Swap(ref a1, ref a2);
+
+            if (Angle.IsBetweenRad(Angle.TwoPI, a1, a2))
+                points.Add(new Vector(arc.Center.X + arc.Radius, arc.Center.Y));
+            if (Angle.IsBetweenRad(Angle.HalfPI, a1, a2))
+                points.Add(new Vector(arc.Center.X, arc.Center.Y + arc.Radius));
+            if (Angle.IsBetweenRad(System.Math.PI, a1, a2))
+                points.Add(new Vector(arc.Center.X - arc.Radius, arc.Center.Y));
+            if (Angle.IsBetweenRad(System.Math.PI * 1.5, a1, a2))
+                points.Add(new Vector(arc.Center.X, arc.Center.Y - arc.Radius));
+        }
+
+        private static HashSet<Vector> CollectVertices(List<Line> lines, Vector offset)
+        {
+            return CollectVertices(ToEdgeArray(lines), offset);
+        }
+
+        private static HashSet<Vector> CollectVertices((Vector start, Vector end)[] edges, Vector offset)
+        {
+            var vertices = new HashSet<Vector>();
+            for (var i = 0; i < edges.Length; i++)
+            {
+                vertices.Add(edges[i].start + offset);
+                vertices.Add(edges[i].end + offset);
+            }
+            return vertices;
+        }
+
+        private static (Vector start, Vector end)[] ToEdgeArray(List<Line> lines)
+        {
+            var edges = new (Vector start, Vector end)[lines.Count];
+            for (var i = 0; i < lines.Count; i++)
+                edges[i] = (lines[i].pt1, lines[i].pt2);
+            return edges;
+        }
+
+        private static void SortEdgesForPruning((Vector start, Vector end)[] edges, PushDirection direction)
+        {
+            if (direction == PushDirection.Left || direction == PushDirection.Right)
+                System.Array.Sort(edges, (a, b) =>
+                    System.Math.Min(a.start.Y, a.end.Y).CompareTo(System.Math.Min(b.start.Y, b.end.Y)));
+            else
+                System.Array.Sort(edges, (a, b) =>
+                    System.Math.Min(a.start.X, a.end.X).CompareTo(System.Math.Min(b.start.X, b.end.X)));
+        }
+
+        private static bool TryGetCurveParams(Entity entity, out double cx, out double cy, out double r)
+        {
+            if (entity is Circle circle)
+            {
+                cx = circle.Center.X; cy = circle.Center.Y; r = circle.Radius;
+                return true;
+            }
+            if (entity is Arc arc)
+            {
+                cx = arc.Center.X; cy = arc.Center.Y; r = arc.Radius;
+                return true;
+            }
+            cx = cy = r = 0;
+            return false;
+        }
+
         private static double BoxProjectionMin(Box box, double dx, double dy)
         {
             var x = dx >= 0 ? box.Left : box.Right;

OpenNest.Core/IConfigurablePostProcessor.cs

@@ -0,0 +1,9 @@
+namespace OpenNest
+{
+    public interface IConfigurablePostProcessor : IPostProcessor
+    {
+        object Config { get; }
+
+        void SaveConfig();
+    }
+}

OpenNest.Core/IMaterialProvidingPostProcessor.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace OpenNest
+{
+    public interface IMaterialProvidingPostProcessor
+    {
+        IEnumerable<string> GetMaterialNames();
+    }
+}

OpenNest.Core/IPostProcessorNestAware.cs

@@ -0,0 +1,7 @@
+namespace OpenNest
+{
+    public interface IPostProcessorNestAware
+    {
+        void PrepareForNest(Nest nest);
+    }
+}

OpenNest.Core/Math/ExpressionEvaluator.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace OpenNest.Math
+{
+    /// <summary>
+    /// Recursive descent parser for simple arithmetic expressions supporting
+    /// +, -, *, /, parentheses, unary minus/plus, and $variable references.
+    /// </summary>
+    public static class ExpressionEvaluator
+    {
+        public static double Evaluate(string expression, IReadOnlyDictionary<string, double> variables)
+        {
+            var parser = new Parser(expression, variables);
+            var result = parser.ParseExpression();
+            parser.SkipWhitespace();
+            if (!parser.IsEnd)
+                throw new FormatException($"Unexpected character at position {parser.Position}: '{parser.Current}'");
+            return result;
+        }
+
+        private ref struct Parser
+        {
+            private readonly ReadOnlySpan<char> _input;
+            private readonly IReadOnlyDictionary<string, double> _variables;
+            private int _pos;
+
+            public Parser(string input, IReadOnlyDictionary<string, double> variables)
+            {
+                _input = input.AsSpan();
+                _variables = variables;
+                _pos = 0;
+            }
+
+            public int Position => _pos;
+            public bool IsEnd => _pos >= _input.Length;
+            public char Current => _input[_pos];
+
+            public void SkipWhitespace()
+            {
+                while (_pos < _input.Length && _input[_pos] == ' ')
+                    _pos++;
+            }
+
+            // Expression = Term (('+' | '-') Term)*
+            public double ParseExpression()
+            {
+                SkipWhitespace();
+                var left = ParseTerm();
+
+                while (true)
+                {
+                    SkipWhitespace();
+                    if (IsEnd) break;
+
+                    var op = Current;
+                    if (op != '+' && op != '-') break;
+
+                    _pos++;
+                    SkipWhitespace();
+                    var right = ParseTerm();
+
+                    left = op == '+' ? left + right : left - right;
+                }
+
+                return left;
+            }
+
+            // Term = Unary (('*' | '/') Unary)*
+            private double ParseTerm()
+            {
+                var left = ParseUnary();
+
+                while (true)
+                {
+                    SkipWhitespace();
+                    if (IsEnd) break;
+
+                    var op = Current;
+                    if (op != '*' && op != '/') break;
+
+                    _pos++;
+                    SkipWhitespace();
+                    var right = ParseUnary();
+
+                    left = op == '*' ? left * right : left / right;
+                }
+
+                return left;
+            }
+
+            // Unary = ('-' | '+')? Primary
+            private double ParseUnary()
+            {
+                SkipWhitespace();
+                if (!IsEnd && Current == '-')
+                {
+                    _pos++;
+                    return -ParsePrimary();
+                }
+                if (!IsEnd && Current == '+')
+                {
+                    _pos++;
+                }
+                return ParsePrimary();
+            }
+
+            // Primary = '(' Expression ')' | '$' Identifier | Number
+            private double ParsePrimary()
+            {
+                SkipWhitespace();
+
+                if (IsEnd)
+                    throw new FormatException("Unexpected end of expression.");
+
+                if (Current == '(')
+                {
+                    _pos++; // consume '('
+                    var value = ParseExpression();
+                    SkipWhitespace();
+                    if (IsEnd || Current != ')')
+                        throw new FormatException("Expected closing parenthesis.");
+                    _pos++; // consume ')'
+                    return value;
+                }
+
+                if (Current == '$')
+                {
+                    _pos++; // consume '$'
+                    var start = _pos;
+                    while (_pos < _input.Length && (char.IsLetterOrDigit(_input[_pos]) || _input[_pos] == '_'))
+                        _pos++;
+                    if (_pos == start)
+                        throw new FormatException("Expected variable name after '$'.");
+                    var name = _input.Slice(start, _pos - start).ToString();
+                    if (!_variables.TryGetValue(name, out var varValue))
+                        throw new KeyNotFoundException($"Undefined variable: ${name}");
+                    return varValue;
+                }
+
+                // Number
+                var numStart = _pos;
+                while (_pos < _input.Length && (char.IsDigit(_input[_pos]) || _input[_pos] == '.'))
+                    _pos++;
+
+                if (_pos == numStart)
+                    throw new FormatException($"Unexpected character '{Current}' at position {_pos}.");
+
+                var numSpan = _input.Slice(numStart, _pos - numStart).ToString();
+                if (!double.TryParse(numSpan, NumberStyles.Float, CultureInfo.InvariantCulture, out var number))
+                    throw new FormatException($"Invalid number: '{numSpan}'");
+
+                return number;
+            }
+        }
+    }
+}

OpenNest.Core/Nest.cs

@@ -1,6 +1,7 @@
 using OpenNest.Collections;
 using OpenNest.Geometry;
 using System;
+using System.Collections.Generic;
 
 namespace OpenNest
 {
@@ -21,6 +22,7 @@ namespace OpenNest
             Plates.ItemRemoved += Plates_PlateRemoved;
             Drawings = new DrawingCollection();
             PlateDefaults = new PlateSettings();
+            Material = new Material();
             Customer = string.Empty;
             Notes = string.Empty;
         }
@@ -38,6 +40,10 @@ namespace OpenNest
 
         public string AssistGas { get; set; } = "";
 
+        public double Thickness { get; set; }
+
+        public Material Material { get; set; }
+
         public Units Units { get; set; }
 
         public DateTime DateCreated { get; set; }
@@ -46,6 +52,10 @@ namespace OpenNest
 
         public PlateSettings PlateDefaults { get; set; }
 
+        public List<PlateOption> PlateOptions { get; set; } = new();
+
+        public double SalvageRate { get; set; } = 0.5;
+
         public Plate CreatePlate()
         {
             var plate = PlateDefaults.CreateNew();
@@ -84,18 +94,6 @@ namespace OpenNest
                 set { plate.Quadrant = value; }
             }
 
-            public double Thickness
-            {
-                get { return plate.Thickness; }
-                set { plate.Thickness = value; }
-            }
-
-            public Material Material
-            {
-                get { return plate.Material; }
-                set { plate.Material = value; }
-            }
-
             public Size Size
             {
                 get { return plate.Size; }
@@ -116,9 +114,7 @@ namespace OpenNest
 
             public void SetFromExisting(Plate plate)
             {
-                Thickness = plate.Thickness;
                 Quadrant = plate.Quadrant;
-                Material = plate.Material;
                 Size = plate.Size;
                 EdgeSpacing = plate.EdgeSpacing;
                 PartSpacing = plate.PartSpacing;
@@ -128,11 +124,9 @@ namespace OpenNest
             {
                 return new Plate()
                 {
-                    Thickness = Thickness,
                     Size = Size,
                     EdgeSpacing = EdgeSpacing,
                     PartSpacing = PartSpacing,
-                    Material = Material,
                     Quadrant = Quadrant,
                     Quantity = 1
                 };

OpenNest.Core/Part.cs

@@ -22,6 +22,7 @@ namespace OpenNest
     {
         private Vector location;
         private bool ownsProgram;
+        private double preLeadInRotation;
 
         public readonly Drawing BaseDrawing;
 
@@ -56,12 +57,61 @@ namespace OpenNest
 
         public bool HasManualLeadIns { get; set; }
 
+        public bool LeadInsLocked { get; set; }
+
+        public CNC.CuttingStrategy.CuttingParameters CuttingParameters { get; set; }
+
+        public void ApplyLeadIns(CNC.CuttingStrategy.CuttingParameters parameters, Vector approachPoint)
+        {
+            ApplyLeadIns(parameters, approachPoint, Geometry.Vector.Invalid);
+        }
+
+        public void ApplyLeadIns(CNC.CuttingStrategy.CuttingParameters parameters, Vector approachPoint, Vector nextPartStart)
+        {
+            preLeadInRotation = Rotation;
+            var strategy = new CNC.CuttingStrategy.ContourCuttingStrategy { Parameters = parameters };
+            var result = strategy.Apply(Program, approachPoint, nextPartStart);
+            Program = result.Program;
+            CuttingParameters = parameters;
+            HasManualLeadIns = true;
+            UpdateBounds();
+        }
+
+        public void ApplySingleLeadIn(CNC.CuttingStrategy.CuttingParameters parameters,
+            Geometry.Vector point, Geometry.Entity entity, CNC.CuttingStrategy.ContourType contourType)
+        {
+            preLeadInRotation = Rotation;
+            var strategy = new CNC.CuttingStrategy.ContourCuttingStrategy { Parameters = parameters };
+            var result = strategy.ApplySingle(Program, point, entity, contourType);
+            Program = result.Program;
+            CuttingParameters = parameters;
+            HasManualLeadIns = true;
+            UpdateBounds();
+        }
+
+        public void RemoveLeadIns()
+        {
+            var rotation = preLeadInRotation;
+            var location = Location;
+            Program = BaseDrawing.Program.Clone() as Program;
+            ownsProgram = true;
+
+            if (!Math.Tolerance.IsEqualTo(rotation, 0))
+                Program.Rotate(rotation);
+
+            Location = location;
+            HasManualLeadIns = false;
+            LeadInsLocked = false;
+            CuttingParameters = null;
+            UpdateBounds();
+        }
+
         /// <summary>
         /// Gets the rotation of the part in radians.
         /// </summary>
         public double Rotation
         {
-            get { return Program.Rotation; }
+            get { return HasManualLeadIns ? preLeadInRotation : Program.Rotation; }
         }
 
         /// <summary>
@@ -73,6 +123,7 @@ namespace OpenNest
             EnsureOwnedProgram();
             Program.Rotate(angle);
             location = Location.Rotate(angle);
+            preLeadInRotation = Program.Rotation;
             UpdateBounds();
         }
 
@@ -86,6 +137,7 @@ namespace OpenNest
             EnsureOwnedProgram();
             Program.Rotate(angle);
             location = Location.Rotate(angle, origin);
+            preLeadInRotation = Program.Rotation;
             UpdateBounds();
         }
 
@@ -143,7 +195,14 @@ namespace OpenNest
         {
             var rotation = Rotation;
             Program = BaseDrawing.Program.Clone() as Program;
-            Program.Rotate(Program.Rotation - rotation);
+
+            if (!Math.Tolerance.IsEqualTo(rotation, 0))
+                Program.Rotate(rotation);
+
+            HasManualLeadIns = false;
+            LeadInsLocked = false;
+            CuttingParameters = null;
+            UpdateBounds();
         }
 
         /// <summary>
@@ -230,7 +289,7 @@ namespace OpenNest
             var part = new Part(BaseDrawing, Program,
                 location + offset,
                 new Box(BoundingBox.X + offset.X, BoundingBox.Y + offset.Y,
-                    BoundingBox.Width, BoundingBox.Length));
+                    BoundingBox.Length, BoundingBox.Width));
 
             return part;
         }

OpenNest.Core/PartGeometry.cs

@@ -39,7 +39,115 @@ namespace OpenNest
             return lines;
         }
 
-        public static List<Line> GetOffsetPartLines(Part part, double spacing, double chordTolerance = 0.001)
+        /// <summary>
+        /// Returns the perimeter entities (Line, Arc, Circle) with spacing offset applied,
+        /// without tessellation. Much faster than GetOffsetPartLines for parts with many arcs.
+        /// </summary>
+        public static List<Entity> GetOffsetPerimeterEntities(Part part, double spacing)
+        {
+            var geoEntities = ConvertProgram.ToGeometry(part.Program);
+            var profile = new ShapeProfile(
+                geoEntities.Where(e => e.Layer != SpecialLayers.Rapid).ToList());
+
+            var offsetShape = profile.Perimeter.OffsetOutward(spacing);
+            if (offsetShape == null)
+                return new List<Entity>();
+
+            // Offset the shape's entities to the part's location.
+            // OffsetOutward creates a new Shape, so mutating is safe.
+            foreach (var entity in offsetShape.Entities)
+                entity.Offset(part.Location);
+
+            return offsetShape.Entities;
+        }
+
+        /// <summary>
+        /// Returns all entities (perimeter + cutouts) with spacing offset applied,
+        /// without tessellation. Perimeter is offset outward, cutouts inward.
+        /// </summary>
+        public static List<Entity> GetOffsetPartEntities(Part part, double spacing)
+        {
+            var geoEntities = ConvertProgram.ToGeometry(part.Program);
+            var profile = new ShapeProfile(
+                geoEntities.Where(e => e.Layer != SpecialLayers.Rapid).ToList());
+            var entities = new List<Entity>();
+
+            var perimeter = profile.Perimeter.OffsetOutward(spacing);
+            if (perimeter != null)
+            {
+                foreach (var entity in perimeter.Entities)
+                    entity.Offset(part.Location);
+                entities.AddRange(perimeter.Entities);
+            }
+
+            foreach (var cutout in profile.Cutouts)
+            {
+                var inset = cutout.OffsetInward(spacing);
+                if (inset == null) continue;
+                foreach (var entity in inset.Entities)
+                    entity.Offset(part.Location);
+                entities.AddRange(inset.Entities);
+            }
+
+            return entities;
+        }
+
+        /// <summary>
+        /// Returns perimeter entities at the part's world location, without tessellation
+        /// or spacing offset.
+        /// </summary>
+        public static List<Entity> GetPerimeterEntities(Part part)
+        {
+            var geoEntities = ConvertProgram.ToGeometry(part.Program);
+            var profile = new ShapeProfile(
+                geoEntities.Where(e => e.Layer != SpecialLayers.Rapid).ToList());
+
+            return CopyEntitiesAtLocation(profile.Perimeter.Entities, part.Location);
+        }
+
+        /// <summary>
+        /// Returns all entities (perimeter + cutouts) at the part's world location,
+        /// without tessellation or spacing offset.
+        /// </summary>
+        public static List<Entity> GetPartEntities(Part part)
+        {
+            var geoEntities = ConvertProgram.ToGeometry(part.Program);
+            var profile = new ShapeProfile(
+                geoEntities.Where(e => e.Layer != SpecialLayers.Rapid).ToList());
+            var entities = CopyEntitiesAtLocation(profile.Perimeter.Entities, part.Location);
+
+            foreach (var cutout in profile.Cutouts)
+                entities.AddRange(CopyEntitiesAtLocation(cutout.Entities, part.Location));
+
+            return entities;
+        }
+
+        private static List<Entity> CopyEntitiesAtLocation(List<Entity> source, Vector location)
+        {
+            var result = new List<Entity>(source.Count);
+
+            for (var i = 0; i < source.Count; i++)
+            {
+                var entity = source[i];
+                Entity copy;
+
+                if (entity is Line line)
+                    copy = new Line(line.StartPoint + location, line.EndPoint + location);
+                else if (entity is Arc arc)
+                    copy = new Arc(arc.Center + location, arc.Radius, arc.StartAngle, arc.EndAngle, arc.IsReversed);
+                else if (entity is Circle circle)
+                    copy = new Circle(circle.Center + location, circle.Radius);
+                else
+                    continue;
+
+                result.Add(copy);
+            }
+
+            return result;
+        }
+
+        public static List<Line> GetOffsetPartLines(Part part, double spacing, double chordTolerance = 0.001,
+            bool perimeterOnly = false)
         {
             var entities = ConvertProgram.ToGeometry(part.Program);
             var profile = new ShapeProfile(
@@ -50,9 +158,12 @@ namespace OpenNest
             AddOffsetLines(lines, profile.Perimeter.OffsetOutward(totalSpacing),
                 chordTolerance, part.Location);
 
-            foreach (var cutout in profile.Cutouts)
+            if (!perimeterOnly)
-                AddOffsetLines(lines, cutout.OffsetInward(totalSpacing),
+            {
-                    chordTolerance, part.Location);
+                foreach (var cutout in profile.Cutouts)
+                    AddOffsetLines(lines, cutout.OffsetInward(totalSpacing),
+                        chordTolerance, part.Location);
+            }
 
             return lines;
         }

OpenNest.Core/Plate.cs

@@ -43,7 +43,6 @@ namespace OpenNest
         {
             EdgeSpacing = new Spacing();
             Size = size;
-            Material = new Material();
             Parts = new ObservableList<Part>();
             Parts.ItemAdded += Parts_PartAdded;
             Parts.ItemRemoved += Parts_PartRemoved;
@@ -63,11 +62,6 @@ namespace OpenNest
                 e.Item.BaseDrawing.Quantity.Nested -= Quantity;
         }
 
-        /// <summary>
-        /// Thickness of the plate.
-        /// </summary>
-        public double Thickness { get; set; }
-
         /// <summary>
         /// The spacing between parts.
         /// </summary>
@@ -83,10 +77,7 @@ namespace OpenNest
         /// </summary>
         public Size Size { get; set; }
 
-        /// <summary>
+        public CNC.CuttingStrategy.CuttingParameters CuttingParameters { get; set; }
-        /// Material the plate is made out of.
-        /// </summary>
-        public Material Material { get; set; }
 
         /// <summary>
         /// Material grain direction in radians. 0 = horizontal.
@@ -433,7 +424,7 @@ namespace OpenNest
         {
             var plateBox = new Box();
 
-            // Convention: Size.Length = X axis (horizontal), Size.Width = Y axis (vertical)
+            // Width = Y axis (vertical), Length = X axis (horizontal)
             switch (Quadrant)
             {
                 case 1:
@@ -460,8 +451,8 @@ namespace OpenNest
                     return new Box();
             }
 
-            plateBox.Width = Size.Length;
+            plateBox.Width = Size.Width;
-            plateBox.Length = Size.Width;
+            plateBox.Length = Size.Length;
 
             if (!includeParts)
                 return plateBox;
@@ -477,11 +468,11 @@ namespace OpenNest
                 ? partsBox.Bottom
                 : plateBox.Bottom;
 
-            boundingBox.Width = partsBox.Right > plateBox.Right
+            boundingBox.Length = partsBox.Right > plateBox.Right
                 ? partsBox.Right - boundingBox.X
                 : plateBox.Right - boundingBox.X;
 
-            boundingBox.Length = partsBox.Top > plateBox.Top
+            boundingBox.Width = partsBox.Top > plateBox.Top
                 ? partsBox.Top - boundingBox.Y
                 : plateBox.Top - boundingBox.Y;
 
@@ -498,8 +489,8 @@ namespace OpenNest
 
             box.X += EdgeSpacing.Left;
             box.Y += EdgeSpacing.Bottom;
-            box.Width -= EdgeSpacing.Left + EdgeSpacing.Right;
+            box.Length -= EdgeSpacing.Left + EdgeSpacing.Right;
-            box.Length -= EdgeSpacing.Top + EdgeSpacing.Bottom;
+            box.Width -= EdgeSpacing.Top + EdgeSpacing.Bottom;
 
             return box;
         }
@@ -569,19 +560,17 @@ namespace OpenNest
         /// <summary>
         /// Gets the volume of the plate.
         /// </summary>
-        /// <returns></returns>
+        public double Volume(double thickness)
-        public double Volume()
         {
-            return Area() * Thickness;
+            return Area() * thickness;
         }
 
         /// <summary>
         /// Gets the weight of the plate.
         /// </summary>
-        /// <returns></returns>
+        public double Weight(double thickness, double density)
-        public double Weight()
         {
-            return Volume() * Material.Density;
+            return Volume(thickness) * density;
         }
 
         /// <summary>

OpenNest.Core/PlateManager.cs

@@ -0,0 +1,243 @@
+using OpenNest.Collections;
+using System;
+
+namespace OpenNest
+{
+    public class PlateChangedEventArgs : EventArgs
+    {
+        public Plate Plate { get; }
+        public int Index { get; }
+
+        public PlateChangedEventArgs(Plate plate, int index)
+        {
+            Plate = plate;
+            Index = index;
+        }
+    }
+
+    public class PlateManager : IDisposable
+    {
+        private readonly Nest nest;
+        private bool disposed;
+        private bool suppressNavigation;
+        private bool batching;
+        private Plate subscribedLast;
+        private Plate subscribedSecondToLast;
+
+        public event EventHandler<PlateChangedEventArgs> CurrentPlateChanged;
+        public event EventHandler PlateListChanged;
+
+        public PlateManager(Nest nest)
+        {
+            this.nest = nest;
+            nest.Plates.ItemAdded += OnPlateAdded;
+            nest.Plates.ItemRemoved += OnPlateRemoved;
+        }
+
+        public int CurrentIndex { get; private set; }
+
+        public Plate CurrentPlate => nest.Plates.Count > 0 ? nest.Plates[CurrentIndex] : null;
+
+        public int Count => nest.Plates.Count;
+
+        public bool IsFirst => Count == 0 || CurrentIndex <= 0;
+
+        public bool IsLast => CurrentIndex + 1 >= Count;
+
+        public bool CanRemoveCurrent => Count > 1 && CurrentPlate != null && CurrentPlate.Parts.Count > 0;
+
+        public void LoadFirst()
+        {
+            if (Count == 0)
+                return;
+
+            CurrentIndex = 0;
+            FireCurrentPlateChanged();
+        }
+
+        public void LoadLast()
+        {
+            if (Count == 0)
+                return;
+
+            CurrentIndex = Count - 1;
+            FireCurrentPlateChanged();
+        }
+
+        public bool LoadNext()
+        {
+            if (CurrentIndex + 1 >= Count)
+                return false;
+
+            CurrentIndex++;
+            FireCurrentPlateChanged();
+            return true;
+        }
+
+        public bool LoadPrevious()
+        {
+            if (Count == 0 || CurrentIndex - 1 < 0)
+                return false;
+
+            CurrentIndex--;
+            FireCurrentPlateChanged();
+            return true;
+        }
+
+        public void LoadAt(int index)
+        {
+            if (index < 0 || index >= Count)
+                return;
+
+            CurrentIndex = index;
+            FireCurrentPlateChanged();
+        }
+
+        public void EnsureSentinel()
+        {
+            suppressNavigation = true;
+            try
+            {
+                if (Count == 0 || nest.Plates[^1].Parts.Count > 0)
+                    nest.CreatePlate();
+
+                while (Count > 1
+                    && nest.Plates[^1].Parts.Count == 0
+                    && nest.Plates[^2].Parts.Count == 0)
+                {
+                    nest.Plates.RemoveAt(Count - 1);
+                }
+            }
+            finally
+            {
+                suppressNavigation = false;
+            }
+
+            SubscribeToTailPlates();
+        }
+
+        public void BeginBatch()
+        {
+            batching = true;
+        }
+
+        public void EndBatch()
+        {
+            batching = false;
+            EnsureSentinel();
+            PlateListChanged?.Invoke(this, EventArgs.Empty);
+            FireCurrentPlateChanged();
+        }
+
+        public Plate GetOrCreateEmpty()
+        {
+            for (var i = Count - 1; i >= 0; i--)
+            {
+                if (nest.Plates[i].Parts.Count == 0)
+                    return nest.Plates[i];
+            }
+
+            return nest.CreatePlate();
+        }
+
+        public void RemoveCurrent()
+        {
+            if (Count < 2)
+                return;
+
+            nest.Plates.RemoveAt(CurrentIndex);
+        }
+
+        private void SubscribeToTailPlates()
+        {
+            UnsubscribeFromTailPlates();
+
+            if (Count > 0)
+            {
+                subscribedLast = nest.Plates[^1];
+                subscribedLast.PartAdded += OnTailPartAdded;
+                subscribedLast.PartRemoved += OnTailPartRemoved;
+            }
+
+            if (Count > 1)
+            {
+                subscribedSecondToLast = nest.Plates[^2];
+                subscribedSecondToLast.PartAdded += OnTailPartAdded;
+                subscribedSecondToLast.PartRemoved += OnTailPartRemoved;
+            }
+        }
+
+        private void UnsubscribeFromTailPlates()
+        {
+            if (subscribedLast != null)
+            {
+                subscribedLast.PartAdded -= OnTailPartAdded;
+                subscribedLast.PartRemoved -= OnTailPartRemoved;
+                subscribedLast = null;
+            }
+
+            if (subscribedSecondToLast != null)
+            {
+                subscribedSecondToLast.PartAdded -= OnTailPartAdded;
+                subscribedSecondToLast.PartRemoved -= OnTailPartRemoved;
+                subscribedSecondToLast = null;
+            }
+        }
+
+        private void OnTailPartAdded(object sender, ItemAddedEventArgs<Part> e)
+        {
+            if (!batching)
+                EnsureSentinel();
+        }
+
+        private void OnTailPartRemoved(object sender, ItemRemovedEventArgs<Part> e)
+        {
+            if (!batching)
+                EnsureSentinel();
+        }
+
+        private void OnPlateAdded(object sender, ItemAddedEventArgs<Plate> e)
+        {
+            if (!suppressNavigation && !batching)
+                EnsureSentinel();
+
+            PlateListChanged?.Invoke(this, EventArgs.Empty);
+
+            if (!suppressNavigation)
+            {
+                CurrentIndex = Count - 1;
+                FireCurrentPlateChanged();
+            }
+        }
+
+        private void OnPlateRemoved(object sender, ItemRemovedEventArgs<Plate> e)
+        {
+            if (CurrentIndex >= Count && Count > 0)
+                CurrentIndex = Count - 1;
+
+            if (!suppressNavigation && !batching)
+                EnsureSentinel();
+
+            PlateListChanged?.Invoke(this, EventArgs.Empty);
+
+            if (!suppressNavigation)
+                FireCurrentPlateChanged();
+        }
+
+        private void FireCurrentPlateChanged()
+        {
+            CurrentPlateChanged?.Invoke(this, new PlateChangedEventArgs(CurrentPlate, CurrentIndex));
+        }
+
+        public void Dispose()
+        {
+            if (disposed)
+                return;
+
+            disposed = true;
+            UnsubscribeFromTailPlates();
+            nest.Plates.ItemAdded -= OnPlateAdded;
+            nest.Plates.ItemRemoved -= OnPlateRemoved;
+        }
+    }
+}

OpenNest.Core/PlateOptimizerResult.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace OpenNest
+{
+    public class PlateOptimizerResult
+    {
+        public List<Part> Parts { get; set; } = new();
+        public PlateOption ChosenSize { get; set; }
+        public double NetCost { get; set; }
+        public double Utilization { get; set; }
+    }
+}

OpenNest.Core/PlateOption.cs

@@ -0,0 +1,11 @@
+namespace OpenNest
+{
+    public class PlateOption
+    {
+        public double Width { get; set; }
+        public double Length { get; set; }
+        public double Cost { get; set; }
+
+        public double Area => Width * Length;
+    }
+}

OpenNest.Core/Shapes/CircleShape.cs

@@ -7,6 +7,11 @@ namespace OpenNest.Shapes
     {
         public double Diameter { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Diameter = 8;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>

OpenNest.Core/Shapes/FlangeShape.cs

@@ -11,6 +11,15 @@ namespace OpenNest.Shapes
         public double HolePatternDiameter { get; set; }
         public int HoleCount { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            NominalPipeSize = 2;
+            OD = 7.5;
+            HoleDiameter = 0.875;
+            HolePatternDiameter = 5.5;
+            HoleCount = 8;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>();

OpenNest.Core/Shapes/IsoscelesTriangleShape.cs

@@ -8,6 +8,12 @@ namespace OpenNest.Shapes
         public double Base { get; set; }
         public double Height { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Base = 8;
+            Height = 10;
+        }
+
         public override Drawing GetDrawing()
         {
             var midX = Base / 2.0;

OpenNest.Core/Shapes/LShape.cs

@@ -10,6 +10,14 @@ namespace OpenNest.Shapes
         public double LegWidth { get; set; }
         public double LegHeight { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Width = 8;
+            Height = 10;
+            LegWidth = 3;
+            LegHeight = 3;
+        }
+
         public override Drawing GetDrawing()
         {
             var lw = LegWidth > 0 ? LegWidth : Width / 2.0;

OpenNest.Core/Shapes/OctagonShape.cs

@@ -7,6 +7,11 @@ namespace OpenNest.Shapes
     {
         public double Width { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Width = 8;
+        }
+
         public override Drawing GetDrawing()
         {
             var center = Width / 2.0;

OpenNest.Core/Shapes/RectangleShape.cs

@@ -8,6 +8,12 @@ namespace OpenNest.Shapes
         public double Length { get; set; }
         public double Width { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Length = 12;
+            Width = 6;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>

OpenNest.Core/Shapes/RightTriangleShape.cs

@@ -8,6 +8,12 @@ namespace OpenNest.Shapes
         public double Width { get; set; }
         public double Height { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Width = 8;
+            Height = 6;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>

OpenNest.Core/Shapes/RingShape.cs

@@ -8,6 +8,12 @@ namespace OpenNest.Shapes
         public double OuterDiameter { get; set; }
         public double InnerDiameter { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            OuterDiameter = 10;
+            InnerDiameter = 6;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>

OpenNest.Core/Shapes/RoundedRectangleShape.cs

@@ -10,6 +10,13 @@ namespace OpenNest.Shapes
         public double Width { get; set; }
         public double Radius { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Length = 12;
+            Width = 6;
+            Radius = 1;
+        }
+
         public override Drawing GetDrawing()
         {
             var r = Radius;

OpenNest.Core/Shapes/ShapeDefinition.cs

@@ -26,6 +26,8 @@ namespace OpenNest.Shapes
 
         public abstract Drawing GetDrawing();
 
+        public virtual void SetPreviewDefaults() { }
+
         public static List<T> LoadFromJson<T>(string path) where T : ShapeDefinition
         {
             var json = File.ReadAllText(path);

OpenNest.Core/Shapes/TShape.cs

@@ -10,6 +10,14 @@ namespace OpenNest.Shapes
         public double StemWidth { get; set; }
         public double BarHeight { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            Width = 10;
+            Height = 8;
+            StemWidth = 3;
+            BarHeight = 3;
+        }
+
         public override Drawing GetDrawing()
         {
             var sw = StemWidth > 0 ? StemWidth : Width / 3.0;

OpenNest.Core/Shapes/TrapezoidShape.cs

@@ -9,6 +9,13 @@ namespace OpenNest.Shapes
         public double BottomWidth { get; set; }
         public double Height { get; set; }
 
+        public override void SetPreviewDefaults()
+        {
+            TopWidth = 6;
+            BottomWidth = 10;
+            Height = 6;
+        }
+
         public override Drawing GetDrawing()
         {
             var offset = (BottomWidth - TopWidth) / 2.0;

OpenNest.Core/SpecialLayers.cs

@@ -13,9 +13,9 @@ namespace OpenNest
 
         public static readonly Layer Display = new Layer("DISPLAY") { Color = Color.Cyan };
 
-        public static readonly Layer Leadin = new Layer("LEADIN") { Color = Color.Yellow };
+        public static readonly Layer Leadin = new Layer("LEADIN") { Color = Color.Brown };
 
-        public static readonly Layer Leadout = new Layer("LEADOUT") { Color = Color.Yellow };
+        public static readonly Layer Leadout = new Layer("LEADOUT") { Color = Color.Brown };
 
         public static readonly Layer Scribe = new Layer("SCRIBE") { Color = Color.Magenta };
     }

OpenNest.Core/Splitting/AutoSplitCalculator.cs

@@ -13,8 +13,8 @@ public static class AutoSplitCalculator
 
         var lines = new List<SplitLine>();
 
-        var verticalSplits = usableWidth > 0 ? (int)System.Math.Ceiling(partBounds.Width / usableWidth) - 1 : 0;
+        var verticalSplits = usableWidth > 0 ? (int)System.Math.Ceiling(partBounds.Length / usableWidth) - 1 : 0;
-        var horizontalSplits = usableHeight > 0 ? (int)System.Math.Ceiling(partBounds.Length / usableHeight) - 1 : 0;
+        var horizontalSplits = usableHeight > 0 ? (int)System.Math.Ceiling(partBounds.Width / usableHeight) - 1 : 0;
 
         if (verticalSplits < 0) verticalSplits = 0;
         if (horizontalSplits < 0) horizontalSplits = 0;
@@ -34,14 +34,14 @@ public static class AutoSplitCalculator
 
         if (verticalPieces > 1)
         {
-            var spacing = partBounds.Width / verticalPieces;
+            var spacing = partBounds.Length / verticalPieces;
             for (var i = 1; i < verticalPieces; i++)
                 lines.Add(new SplitLine(partBounds.X + spacing * i, CutOffAxis.Vertical));
         }
 
         if (horizontalPieces > 1)
         {
-            var spacing = partBounds.Length / horizontalPieces;
+            var spacing = partBounds.Width / horizontalPieces;
             for (var i = 1; i < horizontalPieces; i++)
                 lines.Add(new SplitLine(partBounds.Y + spacing * i, CutOffAxis.Horizontal));
         }

OpenNest.Engine/BestFit/BestFitFilter.cs

@@ -17,7 +17,8 @@ namespace OpenNest.Engine.BestFit
                 if (!result.Keep)
                     continue;
 
-                if (result.ShortestSide > System.Math.Min(MaxPlateWidth, MaxPlateHeight))
+                if (result.ShortestSide > System.Math.Min(MaxPlateWidth, MaxPlateHeight) ||
+                    result.LongestSide > System.Math.Max(MaxPlateWidth, MaxPlateHeight))
                 {
                     result.Keep = false;
                     result.Reason = "Exceeds plate dimensions";

OpenNest.Engine/BestFit/BestFitFinder.cs

@@ -4,6 +4,7 @@ using OpenNest.Geometry;
 using OpenNest.Math;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -49,6 +50,8 @@ namespace OpenNest.Engine.BestFit
 
             var allCandidates = candidateBags.SelectMany(c => c).ToList();
 
+            Debug.WriteLine($"[BestFitFinder] {strategies.Count} strategies, {allCandidates.Count} candidates");
+
             var results = _evaluator.EvaluateAll(allCandidates);
 
             _filter.Apply(results);

OpenNest.Engine/BestFit/CpuDistanceComputer.cs

@@ -1,4 +1,5 @@
 using OpenNest.Geometry;
+using OpenNest.Math;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -17,7 +18,6 @@ namespace OpenNest.Engine.BestFit
             var allMovingVerts = ExtractUniqueVertices(movingTemplateLines);
             var allStationaryVerts = ExtractUniqueVertices(stationaryLines);
 
-            // Pre-filter vertices per unique direction (typically 4 cardinal directions).
             var vertexCache = new Dictionary<(double, double), (Vector[] leading, Vector[] facing)>();
 
             foreach (var offset in offsets)
@@ -43,7 +43,6 @@ namespace OpenNest.Engine.BestFit
 
                 var minDist = double.MaxValue;
 
-                // Case 1: Leading moving vertices → stationary edges
                 for (var v = 0; v < leadingMoving.Length; v++)
                 {
                     var vx = leadingMoving[v].X + offset.Dx;
@@ -66,7 +65,6 @@ namespace OpenNest.Engine.BestFit
                     }
                 }
 
-                // Case 2: Facing stationary vertices → moving edges (opposite direction)
                 for (var v = 0; v < facingStationary.Length; v++)
                 {
                     var svx = facingStationary[v].X;
@@ -95,6 +93,253 @@ namespace OpenNest.Engine.BestFit
             return results;
         }
 
+        public double[] ComputeDistances(
+            List<Entity> stationaryEntities,
+            List<Entity> movingEntities,
+            SlideOffset[] offsets)
+        {
+            var count = offsets.Length;
+            var results = new double[count];
+
+            var allMovingVerts = ExtractVerticesFromEntities(movingEntities);
+            var allStationaryVerts = ExtractVerticesFromEntities(stationaryEntities);
+
+            var movingCurves = ExtractCurveParams(movingEntities);
+            var stationaryCurves = ExtractCurveParams(stationaryEntities);
+
+            var vertexCache = new Dictionary<(double, double), (Vector[] leading, Vector[] facing)>();
+
+            foreach (var offset in offsets)
+            {
+                var key = (offset.DirX, offset.DirY);
+                if (vertexCache.ContainsKey(key))
+                    continue;
+
+                var leading = FilterVerticesByProjection(allMovingVerts, offset.DirX, offset.DirY, keepHigh: true);
+                var facing = FilterVerticesByProjection(allStationaryVerts, offset.DirX, offset.DirY, keepHigh: false);
+                vertexCache[key] = (leading, facing);
+            }
+
+            System.Threading.Tasks.Parallel.For(0, count, i =>
+            {
+                var offset = offsets[i];
+                var dirX = offset.DirX;
+                var dirY = offset.DirY;
+                var oppX = -dirX;
+                var oppY = -dirY;
+
+                var (leadingMoving, facingStationary) = vertexCache[(dirX, dirY)];
+
+                var minDist = double.MaxValue;
+
+                // Case 1: Leading moving vertices → stationary entities
+                for (var v = 0; v < leadingMoving.Length; v++)
+                {
+                    var vx = leadingMoving[v].X + offset.Dx;
+                    var vy = leadingMoving[v].Y + offset.Dy;
+
+                    for (var j = 0; j < stationaryEntities.Count; j++)
+                    {
+                        var d = RayEntityDistance(vx, vy, stationaryEntities[j], 0, 0, dirX, dirY);
+
+                        if (d < minDist)
+                        {
+                            minDist = d;
+                            if (d <= 0) { results[i] = 0; return; }
+                        }
+                    }
+                }
+
+                // Case 2: Facing stationary vertices → moving entities (opposite direction)
+                for (var v = 0; v < facingStationary.Length; v++)
+                {
+                    var svx = facingStationary[v].X;
+                    var svy = facingStationary[v].Y;
+
+                    for (var j = 0; j < movingEntities.Count; j++)
+                    {
+                        var d = RayEntityDistance(svx, svy, movingEntities[j], offset.Dx, offset.Dy, oppX, oppY);
+
+                        if (d < minDist)
+                        {
+                            minDist = d;
+                            if (d <= 0) { results[i] = 0; return; }
+                        }
+                    }
+                }
+
+                // Phase 3: Curve-to-curve direct distance.
+                // Vertex sampling misses the true contact between two curved entities
+                // when the approach angle doesn't align with a sampled vertex.
+                for (var m = 0; m < movingCurves.Length; m++)
+                {
+                    var mc = movingCurves[m];
+                    var mcx = mc.Cx + offset.Dx;
+                    var mcy = mc.Cy + offset.Dy;
+
+                    for (var s = 0; s < stationaryCurves.Length; s++)
+                    {
+                        var sc = stationaryCurves[s];
+                        var d = SpatialQuery.RayCircleDistance(
+                            mcx, mcy, sc.Cx, sc.Cy, mc.Radius + sc.Radius, dirX, dirY);
+
+                        if (d >= minDist || d == double.MaxValue)
+                            continue;
+
+                        if (mc.Entity is Arc || sc.Entity is Arc)
+                        {
+                            var mx = mcx + d * dirX;
+                            var my = mcy + d * dirY;
+                            var toCx = sc.Cx - mx;
+                            var toCy = sc.Cy - my;
+
+                            if (mc.Entity is Arc mArc)
+                            {
+                                var angle = Angle.NormalizeRad(System.Math.Atan2(toCy, toCx));
+                                if (!Angle.IsBetweenRad(angle, mArc.StartAngle, mArc.EndAngle, mArc.IsReversed))
+                                    continue;
+                            }
+
+                            if (sc.Entity is Arc sArc)
+                            {
+                                var angle = Angle.NormalizeRad(System.Math.Atan2(-toCy, -toCx));
+                                if (!Angle.IsBetweenRad(angle, sArc.StartAngle, sArc.EndAngle, sArc.IsReversed))
+                                    continue;
+                            }
+                        }
+
+                        minDist = d;
+                        if (d <= 0) { results[i] = 0; return; }
+                    }
+                }
+
+                results[i] = minDist;
+            });
+
+            return results;
+        }
+
+        private readonly struct CurveParams
+        {
+            public readonly Entity Entity;
+            public readonly double Cx, Cy, Radius;
+
+            public CurveParams(Entity entity, double cx, double cy, double radius)
+            {
+                Entity = entity;
+                Cx = cx;
+                Cy = cy;
+                Radius = radius;
+            }
+        }
+
+        private static CurveParams[] ExtractCurveParams(List<Entity> entities)
+        {
+            var curves = new List<CurveParams>();
+            for (var i = 0; i < entities.Count; i++)
+            {
+                if (entities[i] is Circle circle)
+                    curves.Add(new CurveParams(circle, circle.Center.X, circle.Center.Y, circle.Radius));
+                else if (entities[i] is Arc arc)
+                    curves.Add(new CurveParams(arc, arc.Center.X, arc.Center.Y, arc.Radius));
+            }
+            return curves.ToArray();
+        }
+
+        private static double RayEntityDistance(
+            double vx, double vy, Entity entity,
+            double entityOffsetX, double entityOffsetY,
+            double dirX, double dirY)
+        {
+            if (entity is Line line)
+            {
+                return SpatialQuery.RayEdgeDistance(
+                    vx, vy,
+                    line.StartPoint.X + entityOffsetX, line.StartPoint.Y + entityOffsetY,
+                    line.EndPoint.X + entityOffsetX, line.EndPoint.Y + entityOffsetY,
+                    dirX, dirY);
+            }
+
+            if (entity is Arc arc)
+            {
+                return SpatialQuery.RayArcDistance(
+                    vx, vy,
+                    arc.Center.X + entityOffsetX, arc.Center.Y + entityOffsetY,
+                    arc.Radius,
+                    arc.StartAngle, arc.EndAngle, arc.IsReversed,
+                    dirX, dirY);
+            }
+
+            if (entity is Circle circle)
+            {
+                return SpatialQuery.RayCircleDistance(
+                    vx, vy,
+                    circle.Center.X + entityOffsetX, circle.Center.Y + entityOffsetY,
+                    circle.Radius,
+                    dirX, dirY);
+            }
+
+            return double.MaxValue;
+        }
+
+        private static Vector[] ExtractVerticesFromEntities(List<Entity> entities)
+        {
+            var vertices = new HashSet<Vector>();
+
+            for (var i = 0; i < entities.Count; i++)
+            {
+                var entity = entities[i];
+
+                if (entity is Line line)
+                {
+                    vertices.Add(line.StartPoint);
+                    vertices.Add(line.EndPoint);
+                }
+                else if (entity is Arc arc)
+                {
+                    vertices.Add(arc.StartPoint());
+                    vertices.Add(arc.EndPoint());
+                    AddArcExtremes(vertices, arc);
+                }
+                else if (entity is Circle circle)
+                {
+                    // Four cardinal points
+                    vertices.Add(new Vector(circle.Center.X + circle.Radius, circle.Center.Y));
+                    vertices.Add(new Vector(circle.Center.X - circle.Radius, circle.Center.Y));
+                    vertices.Add(new Vector(circle.Center.X, circle.Center.Y + circle.Radius));
+                    vertices.Add(new Vector(circle.Center.X, circle.Center.Y - circle.Radius));
+                }
+            }
+
+            return vertices.ToArray();
+        }
+
+        private static void AddArcExtremes(HashSet<Vector> points, Arc arc)
+        {
+            var a1 = arc.StartAngle;
+            var a2 = arc.EndAngle;
+            var reversed = arc.IsReversed;
+
+            if (reversed)
+                Generic.Swap(ref a1, ref a2);
+
+            // Right (0°)
+            if (Angle.IsBetweenRad(Angle.TwoPI, a1, a2))
+                points.Add(new Vector(arc.Center.X + arc.Radius, arc.Center.Y));
+
+            // Top (90°)
+            if (Angle.IsBetweenRad(Angle.HalfPI, a1, a2))
+                points.Add(new Vector(arc.Center.X, arc.Center.Y + arc.Radius));
+
+            // Left (180°)
+            if (Angle.IsBetweenRad(System.Math.PI, a1, a2))
+                points.Add(new Vector(arc.Center.X - arc.Radius, arc.Center.Y));
+
+            // Bottom (270°)
+            if (Angle.IsBetweenRad(System.Math.PI * 1.5, a1, a2))
+                points.Add(new Vector(arc.Center.X, arc.Center.Y - arc.Radius));
+        }
+
         private static Vector[] ExtractUniqueVertices(List<Line> lines)
         {
             var vertices = new HashSet<Vector>();
@@ -106,11 +351,6 @@ namespace OpenNest.Engine.BestFit
             return vertices.ToArray();
         }
 
-        /// <summary>
-        /// Filters vertices by their projection onto the push direction.
-        /// keepHigh=true returns the leading half (front face, closest to target).
-        /// keepHigh=false returns the facing half (side facing the approaching part).
-        /// </summary>
         private static Vector[] FilterVerticesByProjection(
             Vector[] vertices, double dirX, double dirY, bool keepHigh)
         {

OpenNest.Engine/BestFit/GpuDistanceComputer.cs

@@ -36,6 +36,16 @@ namespace OpenNest.Engine.BestFit
                 flatOffsets, count, directions);
         }
 
+        public double[] ComputeDistances(
+            List<Entity> stationaryEntities,
+            List<Entity> movingEntities,
+            SlideOffset[] offsets)
+        {
+            // GPU path doesn't support native entities yet — fall back to CPU.
+            var cpu = new CpuDistanceComputer();
+            return cpu.ComputeDistances(stationaryEntities, movingEntities, offsets);
+        }
+
         /// <summary>
         /// Maps a unit direction vector to a PushDirection int for the GPU interface.
         /// Left=0, Down=1, Right=2, Up=3.

OpenNest.Engine/BestFit/IDistanceComputer.cs

@@ -9,5 +9,10 @@ namespace OpenNest.Engine.BestFit
             List<Line> stationaryLines,
             List<Line> movingTemplateLines,
             SlideOffset[] offsets);
+
+        double[] ComputeDistances(
+            List<Entity> stationaryEntities,
+            List<Entity> movingEntities,
+            SlideOffset[] offsets);
     }
 }

OpenNest.Engine/BestFit/PairEvaluator.cs

@@ -15,11 +15,18 @@ namespace OpenNest.Engine.BestFit
 
         public List<BestFitResult> EvaluateAll(List<PairCandidate> candidates)
         {
+            if (candidates.Count == 0)
+                return new List<BestFitResult>();
+
+            // Build a perimeter-only drawing once — all candidates share the same drawing.
+            // This avoids cloning the full program (with all cutouts) for every candidate.
+            var perimeterDrawing = CreatePerimeterDrawing(candidates[0].Drawing);
+
             var resultBag = new ConcurrentBag<BestFitResult>();
 
             Parallel.ForEach(candidates, c =>
             {
-                resultBag.Add(Evaluate(c));
+                resultBag.Add(Evaluate(c, perimeterDrawing));
             });
 
             return resultBag.ToList();
@@ -27,18 +34,24 @@ namespace OpenNest.Engine.BestFit
 
         public BestFitResult Evaluate(PairCandidate candidate)
         {
-            var drawing = candidate.Drawing;
+            var perimeterDrawing = CreatePerimeterDrawing(candidate.Drawing);
+            return Evaluate(candidate, perimeterDrawing);
+        }
 
-            var part1 = Part.CreateAtOrigin(drawing);
+        private BestFitResult Evaluate(PairCandidate candidate, Drawing perimeterDrawing)
+        {
+            var part1 = Part.CreateAtOrigin(perimeterDrawing);
 
-            var part2 = Part.CreateAtOrigin(drawing, candidate.Part2Rotation);
+            var part2 = Part.CreateAtOrigin(perimeterDrawing, candidate.Part2Rotation);
             part2.Location = candidate.Part2Offset;
             part2.UpdateBounds();
 
-            // Check overlap via shape intersection
+            // Overlap check — perimeter vs perimeter
-            var overlaps = CheckOverlap(part1, part2);
+            var shape1 = GetPerimeterShape(part1);
+            var shape2 = GetPerimeterShape(part2);
+            var overlaps = shape1 != null && shape2 != null && shape1.Intersects(shape2, out _);
 
-            // Collect all polygon vertices for convex hull / optimal rotation
+            // Convex hull vertices from perimeter polygons only
             var allPoints = GetPartVertices(part1);
             allPoints.AddRange(GetPartVertices(part2));
 
@@ -66,7 +79,7 @@ namespace OpenNest.Engine.BestFit
                 hullAngles = new List<double> { 0 };
             }
 
-            var trueArea = drawing.Area * 2;
+            var trueArea = candidate.Drawing.Area * 2;
 
             // Normalize to landscape (width >= height) for consistent display.
             if (bestHeight > bestWidth)
@@ -91,38 +104,29 @@ namespace OpenNest.Engine.BestFit
             };
         }
 
-        private bool CheckOverlap(Part part1, Part part2)
+        private static Drawing CreatePerimeterDrawing(Drawing source)
         {
-            var shapes1 = GetPartShapes(part1);
+            var entities = ConvertProgram.ToGeometry(source.Program)
-            var shapes2 = GetPartShapes(part2);
+                .Where(e => e.Layer != SpecialLayers.Rapid).ToList();
-
+            var profile = new ShapeProfile(entities);
-            for (var i = 0; i < shapes1.Count; i++)
+            var program = ConvertGeometry.ToProgram(profile.Perimeter);
-            {
+            return new Drawing(source.Name, program);
-                for (var j = 0; j < shapes2.Count; j++)
-                {
-                    List<Vector> pts;
-
-                    if (shapes1[i].Intersects(shapes2[j], out pts))
-                        return true;
-                }
-            }
-
-            return false;
         }
 
-        private List<Shape> GetPartShapes(Part part)
+        private static Shape GetPerimeterShape(Part part)
         {
             var entities = ConvertProgram.ToGeometry(part.Program)
-                .Where(e => e.Layer != SpecialLayers.Rapid);
+                .Where(e => e.Layer != SpecialLayers.Rapid).ToList();
             var shapes = ShapeBuilder.GetShapes(entities);
-            shapes.ForEach(s => s.Offset(part.Location));
+            if (shapes.Count == 0) return null;
-            return shapes;
+            shapes[0].Offset(part.Location);
+            return shapes[0];
         }
 
-        private List<Vector> GetPartVertices(Part part)
+        private static List<Vector> GetPartVertices(Part part)
         {
             var entities = ConvertProgram.ToGeometry(part.Program)
-                .Where(e => e.Layer != SpecialLayers.Rapid);
+                .Where(e => e.Layer != SpecialLayers.Rapid).ToList();
             var shapes = ShapeBuilder.GetShapes(entities);
             var points = new List<Vector>();
 
@@ -130,9 +134,7 @@ namespace OpenNest.Engine.BestFit
             {
                 var polygon = shape.ToPolygonWithTolerance(ChordTolerance);
                 polygon.Offset(part.Location);
-
+                points.AddRange(polygon.Vertices);
-                foreach (var vertex in polygon.Vertices)
-                    points.Add(vertex);
             }
 
             return points;

OpenNest.Engine/BestFit/RotationSlideStrategy.cs

@@ -36,8 +36,8 @@ namespace OpenNest.Engine.BestFit
             var part2Template = Part.CreateAtOrigin(drawing, Part2Rotation);
 
             var halfSpacing = spacing / 2;
-            var part1Lines = PartGeometry.GetOffsetPartLines(part1, halfSpacing);
+            var part1Entities = PartGeometry.GetOffsetPerimeterEntities(part1, halfSpacing);
-            var part2TemplateLines = PartGeometry.GetOffsetPartLines(part2Template, halfSpacing);
+            var part2Entities = PartGeometry.GetOffsetPerimeterEntities(part2Template, halfSpacing);
 
             var bbox1 = part1.BoundingBox;
             var bbox2 = part2Template.BoundingBox;
@@ -48,7 +48,7 @@ namespace OpenNest.Engine.BestFit
                 return candidates;
 
             var distances = _distanceComputer.ComputeDistances(
-                part1Lines, part2TemplateLines, offsets);
+                part1Entities, part2Entities, offsets);
 
             var testNumber = 0;
 
@@ -89,15 +89,20 @@ namespace OpenNest.Engine.BestFit
 
                 if (isHorizontalPush)
                 {
-                    perpMin = -(bbox2.Length + spacing);
+                    // Perpendicular sweep along Y → Width; push extent along X → Length
-                    perpMax = bbox1.Length + bbox2.Length + spacing;
+                    // Trim to offsets where the parts overlap by at least 50%.
-                    pushStartOffset = bbox1.Width + bbox2.Width + spacing * 2;
+                    var halfOverlap = bbox2.Width * 0.5;
+                    perpMin = -(halfOverlap - spacing);
+                    perpMax = bbox1.Width + halfOverlap + spacing;
+                    pushStartOffset = bbox1.Length + bbox2.Length + spacing * 2;
                 }
                 else
                 {
-                    perpMin = -(bbox2.Width + spacing);
+                    // Perpendicular sweep along X → Length; push extent along Y → Width
-                    perpMax = bbox1.Width + bbox2.Width + spacing;
+                    var halfOverlap = bbox2.Length * 0.5;
-                    pushStartOffset = bbox1.Length + bbox2.Length + spacing * 2;
+                    perpMin = -(halfOverlap - spacing);
+                    perpMax = bbox1.Length + halfOverlap + spacing;
+                    pushStartOffset = bbox1.Width + bbox2.Width + spacing * 2;
                 }
 
                 var alignedStart = System.Math.Ceiling(perpMin / stepSize) * stepSize;

OpenNest.Engine/DefaultNestEngine.cs

@@ -1,7 +1,9 @@
 using OpenNest.Engine;
+using OpenNest.Engine.BestFit;
 using OpenNest.Engine.Fill;
 using OpenNest.Engine.Strategies;
 using OpenNest.Geometry;
+using OpenNest.Math;
 using OpenNest.RectanglePacking;
 using System;
 using System.Collections.Generic;
@@ -45,24 +47,50 @@ namespace OpenNest
             PhaseResults.Clear();
             AngleResults.Clear();
 
-            var context = new FillContext
+            // Fast path: for very small quantities, skip the full strategy pipeline.
+            if (item.Quantity > 0 && item.Quantity <= 2)
             {
-                Item = item,
+                var fast = TryFillSmallQuantity(item, workArea);
-                WorkArea = workArea,
+                if (fast != null && fast.Count >= item.Quantity)
-                Plate = Plate,
+                {
-                PlateNumber = PlateNumber,
+                    Debug.WriteLine($"[Fill] Fast path: placed {fast.Count} parts for qty={item.Quantity}");
-                Token = token,
+                    WinnerPhase = NestPhase.Pairs;
-                Progress = progress,
+                    ReportProgress(progress, new ProgressReport
-                Policy = BuildPolicy(),
+                    {
-            };
+                        Phase = WinnerPhase,
+                        PlateNumber = PlateNumber,
+                        Parts = fast,
+                        WorkArea = workArea,
+                        Description = $"Fast path: {fast.Count} parts",
+                        IsOverallBest = true,
+                    });
+                    return fast;
+                }
+            }
 
-            RunPipeline(context);
+            // For low quantities, shrink the work area in both dimensions to avoid
+            // running expensive strategies against the full plate.
+            var effectiveWorkArea = workArea;
+            if (item.Quantity > 0)
+            {
+                effectiveWorkArea = ShrinkWorkArea(item, workArea, Plate.PartSpacing);
 
-            // PhaseResults already synced during RunPipeline.
+                if (effectiveWorkArea != workArea)
-            AngleResults.AddRange(context.AngleResults);
+                    Debug.WriteLine($"[Fill] Low-qty shrink: {item.Quantity} requested, " +
-            WinnerPhase = context.WinnerPhase;
+                        $"from {workArea.Width:F1}x{workArea.Length:F1} " +
+                        $"to {effectiveWorkArea.Width:F1}x{effectiveWorkArea.Length:F1}");
+            }
 
-            var best = context.CurrentBest ?? new List<Part>();
+            var best = RunFillPipeline(item, effectiveWorkArea, progress, token);
+
+            // Fallback: if the reduced area didn't yield enough, retry with full area.
+            if (item.Quantity > 0 && best.Count < item.Quantity && effectiveWorkArea != workArea)
+            {
+                Debug.WriteLine($"[Fill] Low-qty fallback: got {best.Count}, need {item.Quantity}, retrying full area");
+                PhaseResults.Clear();
+                AngleResults.Clear();
+                best = RunFillPipeline(item, workArea, progress, token);
+            }
 
             if (item.Quantity > 0 && best.Count > item.Quantity)
                 best = ShrinkFiller.TrimToCount(best, item.Quantity, TrimAxis);
@@ -80,6 +108,180 @@ namespace OpenNest
             return best;
         }
 
+        /// <summary>
+        /// Fast path for qty 1-2: place a single part or a best-fit pair
+        /// without running the full strategy pipeline.
+        /// </summary>
+        private List<Part> TryFillSmallQuantity(NestItem item, Box workArea)
+        {
+            if (item.Quantity == 1)
+                return TryPlaceSingle(item.Drawing, workArea);
+
+            if (item.Quantity == 2)
+                return TryPlaceBestFitPair(item.Drawing, workArea);
+
+            return null;
+        }
+
+        private static List<Part> TryPlaceSingle(Drawing drawing, Box workArea)
+        {
+            var part = Part.CreateAtOrigin(drawing);
+            if (part.BoundingBox.Width > workArea.Width + Tolerance.Epsilon ||
+                part.BoundingBox.Length > workArea.Length + Tolerance.Epsilon)
+                return null;
+
+            part.Offset(workArea.Location - part.BoundingBox.Location);
+            return new List<Part> { part };
+        }
+
+        private List<Part> TryPlaceBestFitPair(Drawing drawing, Box workArea)
+        {
+            var bestFits = BestFitCache.GetOrCompute(
+                drawing, Plate.Size.Length, Plate.Size.Width, Plate.PartSpacing);
+
+            List<Part> bestPlacement = null;
+
+            foreach (var fit in bestFits)
+            {
+                if (!fit.Keep)
+                    continue;
+
+                // Skip pairs that can't possibly fit the work area in either orientation.
+                if (fit.ShortestSide > System.Math.Min(workArea.Width, workArea.Length) + Tolerance.Epsilon)
+                    continue;
+                if (fit.LongestSide > System.Math.Max(workArea.Width, workArea.Length) + Tolerance.Epsilon)
+                    continue;
+
+                var landscape = fit.BuildParts(drawing);
+                var portrait = RotatePair90(landscape);
+
+                var lFits = TryOffsetToWorkArea(landscape, workArea);
+                var pFits = TryOffsetToWorkArea(portrait, workArea);
+
+                // Pick the better orientation for this pair.
+                List<Part> candidate = null;
+                if (lFits && pFits)
+                    candidate = IsBetterFill(portrait, landscape, workArea) ? portrait : landscape;
+                else if (lFits)
+                    candidate = landscape;
+                else if (pFits)
+                    candidate = portrait;
+
+                if (candidate == null)
+                    continue;
+
+                if (bestPlacement == null || IsBetterFill(candidate, bestPlacement, workArea))
+                    bestPlacement = candidate;
+            }
+
+            return bestPlacement;
+        }
+
+        private static List<Part> RotatePair90(List<Part> parts)
+        {
+            var rotated = new List<Part>(parts.Count);
+            foreach (var p in parts)
+                rotated.Add((Part)p.Clone());
+
+            var bbox = ((IEnumerable<IBoundable>)rotated).GetBoundingBox();
+            var center = bbox.Center;
+
+            foreach (var p in rotated)
+                p.Rotate(-Angle.HalfPI, center);
+
+            var newBbox = ((IEnumerable<IBoundable>)rotated).GetBoundingBox();
+            var offset = new Vector(-newBbox.Left, -newBbox.Bottom);
+            foreach (var p in rotated)
+            {
+                p.Offset(offset);
+                p.UpdateBounds();
+            }
+
+            return rotated;
+        }
+
+        private static bool TryOffsetToWorkArea(List<Part> parts, Box workArea)
+        {
+            var bbox = ((IEnumerable<IBoundable>)parts).GetBoundingBox();
+            if (bbox.Width > workArea.Width + Tolerance.Epsilon ||
+                bbox.Length > workArea.Length + Tolerance.Epsilon)
+                return false;
+
+            var offset = workArea.Location - bbox.Location;
+            foreach (var p in parts)
+            {
+                p.Offset(offset);
+                p.UpdateBounds();
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Shrinks the work area in both dimensions proportionally when the
+        /// requested quantity is much less than the plate capacity.
+        /// </summary>
+        private static Box ShrinkWorkArea(NestItem item, Box workArea, double spacing)
+        {
+            var bbox = item.Drawing.Program.BoundingBox();
+            if (bbox.Width <= 0 || bbox.Length <= 0)
+                return workArea;
+
+            var bin = new Bin { Size = new Size(workArea.Width, workArea.Length) };
+            var packItem = new Item { Size = new Size(bbox.Width + spacing, bbox.Length + spacing) };
+            var packer = new FillBestFit(bin);
+            packer.Fill(packItem);
+            var fullCount = bin.Items.Count;
+
+            if (fullCount <= 0 || fullCount <= item.Quantity)
+                return workArea;
+
+            // Scale both dimensions by sqrt(ratio) so the area shrinks
+            // proportionally. 2x margin gives strategies room to optimize.
+            var ratio = (double)item.Quantity / fullCount;
+            var scale = System.Math.Sqrt(ratio) * 2.0;
+
+            var newWidth = workArea.Width * scale;
+            var newLength = workArea.Length * scale;
+
+            // Ensure at least one part fits.
+            var minWidth = bbox.Width + spacing * 2;
+            var minLength = bbox.Length + spacing * 2;
+            newWidth = System.Math.Max(newWidth, minWidth);
+            newLength = System.Math.Max(newLength, minLength);
+
+            // Clamp to original dimensions.
+            newWidth = System.Math.Min(newWidth, workArea.Width);
+            newLength = System.Math.Min(newLength, workArea.Length);
+
+            if (newWidth >= workArea.Width && newLength >= workArea.Length)
+                return workArea;
+
+            return new Box(workArea.X, workArea.Y, newLength, newWidth);
+        }
+
+        private List<Part> RunFillPipeline(NestItem item, Box workArea,
+            IProgress<NestProgress> progress, CancellationToken token)
+        {
+            var context = new FillContext
+            {
+                Item = item,
+                WorkArea = workArea,
+                Plate = Plate,
+                PlateNumber = PlateNumber,
+                Token = token,
+                Progress = progress,
+                Policy = BuildPolicy(),
+                MaxQuantity = item.Quantity,
+            };
+
+            RunPipeline(context);
+
+            AngleResults.AddRange(context.AngleResults);
+            WinnerPhase = context.WinnerPhase;
+
+            return context.CurrentBest ?? new List<Part>();
+        }
+
         public override List<Part> Fill(List<Part> groupParts, Box workArea,
             IProgress<NestProgress> progress, CancellationToken token)
         {
@@ -146,6 +348,7 @@ namespace OpenNest
                 foreach (var strategy in FillStrategyRegistry.Strategies)
                 {
                     context.Token.ThrowIfCancellationRequested();
+                    context.ActivePhase = strategy.Phase;
 
                     var sw = Stopwatch.StartNew();
                     var result = strategy.Fill(context);
@@ -159,14 +362,18 @@ namespace OpenNest
                     // during progress reporting.
                     PhaseResults.Add(phaseResult);
 
-                    if (context.Policy.Comparer.IsBetter(result, context.CurrentBest, context.WorkArea))
+                    // FillContext.ReportProgress updates CurrentBest during the
+                    // strategy's angle sweep. This catches strategies that return a
+                    // result without reporting it (e.g. RectBestFit).
+                    var improved = context.Policy.Comparer.IsBetter(result, context.CurrentBest, context.WorkArea);
+                    if (improved)
                     {
                         context.CurrentBest = result;
                         context.CurrentBestScore = FillScore.Compute(result, context.WorkArea);
                         context.WinnerPhase = strategy.Phase;
                     }
 
-                    if (context.CurrentBest != null && context.CurrentBest.Count > 0)
+                    if (improved && context.CurrentBest != null && context.CurrentBest.Count > 0)
                     {
                         ReportProgress(context.Progress, new ProgressReport
                         {

OpenNest.Engine/Fill/BestCombination.cs

@@ -2,13 +2,15 @@
 
 namespace OpenNest
 {
+    internal record CombinationResult(bool Found, int Count1, int Count2);
+
     internal static class BestCombination
     {
-        public static bool FindFrom2(double length1, double length2, double overallLength, out int count1, out int count2)
+        public static CombinationResult FindFrom2(double length1, double length2, double overallLength)
         {
             overallLength += Tolerance.Epsilon;
-            count1 = 0;
+            var count1 = 0;
-            count2 = 0;
+            var count2 = 0;
 
             var maxCount1 = (int)System.Math.Floor(overallLength / length1);
             var bestRemnant = overallLength + 1;
@@ -30,7 +32,7 @@ namespace OpenNest
                     break;
             }
 
-            return count1 > 0 || count2 > 0;
+            return new CombinationResult(count1 > 0 || count2 > 0, count1, count2);
         }
     }
 }

OpenNest.Engine/Fill/Compactor.cs

@@ -11,8 +11,6 @@ namespace OpenNest.Engine.Fill
     /// </summary>
     public static class Compactor
     {
-        private const double ChordTolerance = 0.001;
-
         public static double Push(List<Part> movingParts, Plate plate, PushDirection direction)
         {
             var obstacleParts = plate.Parts
@@ -44,7 +42,7 @@ namespace OpenNest.Engine.Fill
             var opposite = -direction;
 
             var obstacleBoxes = new Box[obstacleParts.Count];
-            var obstacleLines = new List<Line>[obstacleParts.Count];
+            var obstacleEntities = new List<Entity>[obstacleParts.Count];
 
             for (var i = 0; i < obstacleParts.Count; i++)
                 obstacleBoxes[i] = obstacleParts[i].BoundingBox;
@@ -61,7 +59,19 @@ namespace OpenNest.Engine.Fill
                     distance = edgeDist;
 
                 var movingBox = moving.BoundingBox;
-                List<Line> movingLines = null;
+                List<Entity> movingEntities = null;
+
+                // Check if any obstacle is inside the moving part — only then
+                // do we need cutout entities on the moving part.
+                var needCutouts = false;
+                for (var i = 0; i < obstacleBoxes.Length; i++)
+                {
+                    if (movingBox.Contains(obstacleBoxes[i]))
+                    {
+                        needCutouts = true;
+                        break;
+                    }
+                }
 
                 for (var i = 0; i < obstacleBoxes.Length; i++)
                 {
@@ -76,15 +86,19 @@ namespace OpenNest.Engine.Fill
                     if (!SpatialQuery.PerpendicularOverlap(movingBox, obstacleBoxes[i], direction))
                         continue;
 
-                    movingLines ??= halfSpacing > 0
+                    movingEntities ??= halfSpacing > 0
-                        ? PartGeometry.GetOffsetPartLines(moving, halfSpacing, direction, ChordTolerance)
+                        ? (needCutouts
-                        : PartGeometry.GetPartLines(moving, direction, ChordTolerance);
+                            ? PartGeometry.GetOffsetPartEntities(moving, halfSpacing)
+                            : PartGeometry.GetOffsetPerimeterEntities(moving, halfSpacing))
+                        : (needCutouts
+                            ? PartGeometry.GetPartEntities(moving)
+                            : PartGeometry.GetPerimeterEntities(moving));
 
-                    obstacleLines[i] ??= halfSpacing > 0
+                    obstacleEntities[i] ??= halfSpacing > 0
-                        ? PartGeometry.GetOffsetPartLines(obstacleParts[i], halfSpacing, opposite, ChordTolerance)
+                        ? PartGeometry.GetOffsetPerimeterEntities(obstacleParts[i], halfSpacing)
-                        : PartGeometry.GetPartLines(obstacleParts[i], opposite, ChordTolerance);
+                        : PartGeometry.GetPerimeterEntities(obstacleParts[i]);
 
-                    var d = SpatialQuery.DirectionalDistance(movingLines, obstacleLines[i], direction);
+                    var d = SpatialQuery.DirectionalDistance(movingEntities, obstacleEntities[i], direction);
                     if (d < distance)
                         distance = d;
                 }
@@ -157,7 +171,7 @@ namespace OpenNest.Engine.Fill
                         continue;
 
                     var gap = SpatialQuery.DirectionalGap(movingBox, obstacleBoxes[i], direction);
-                    var d = gap - partSpacing - 2 * ChordTolerance;
+                    var d = gap - partSpacing - 0.002;
                     if (d < 0) d = 0;
                     if (d < distance)
                         distance = d;

OpenNest.Engine/Fill/FillExtents.cs

@@ -24,10 +24,8 @@ namespace OpenNest.Engine.Fill
         }
 
         public List<Part> Fill(Drawing drawing, double rotationAngle = 0,
-            int plateNumber = 0,
             CancellationToken token = default,
-            IProgress<NestProgress> progress = null,
+            Action<List<Part>, string> reportProgress = null)
-            List<Engine.BestFit.BestFitResult> bestFits = null)
         {
             var pair = BuildPair(drawing, rotationAngle);
             if (pair == null)
@@ -37,14 +35,7 @@ namespace OpenNest.Engine.Fill
             if (column.Count == 0)
                 return new List<Part>();
 
-            NestEngineBase.ReportProgress(progress, new ProgressReport
+            reportProgress?.Invoke(column, $"Extents: initial column {column.Count} parts");
-            {
-                Phase = NestPhase.Extents,
-                PlateNumber = plateNumber,
-                Parts = column,
-                WorkArea = workArea,
-                Description = $"Extents: initial column {column.Count} parts",
-            });
 
             var adjusted = AdjustColumn(pair.Value, column, token);
 
@@ -56,25 +47,11 @@ namespace OpenNest.Engine.Fill
                 adjusted = column;
             }
 
-            NestEngineBase.ReportProgress(progress, new ProgressReport
+            reportProgress?.Invoke(adjusted, $"Extents: column {adjusted.Count} parts");
-            {
-                Phase = NestPhase.Extents,
-                PlateNumber = plateNumber,
-                Parts = adjusted,
-                WorkArea = workArea,
-                Description = $"Extents: column {adjusted.Count} parts",
-            });
 
             var result = RepeatColumns(adjusted, token);
 
-            NestEngineBase.ReportProgress(progress, new ProgressReport
+            reportProgress?.Invoke(result, $"Extents: {result.Count} parts total");
-            {
-                Phase = NestPhase.Extents,
-                PlateNumber = plateNumber,
-                Parts = result,
-                WorkArea = workArea,
-                Description = $"Extents: {result.Count} parts total",
-            });
 
             return result;
         }
@@ -96,7 +73,7 @@ namespace OpenNest.Engine.Fill
             var boundary2 = new PartBoundary(part2, halfSpacing);
 
             // Position part2 to the right of part1 at bounding box width distance.
-            var startOffset = part1.BoundingBox.Width + part2.BoundingBox.Width + partSpacing;
+            var startOffset = part1.BoundingBox.Length + part2.BoundingBox.Length + partSpacing;
             part2.Offset(startOffset, 0);
             part2.UpdateBounds();
 
@@ -135,7 +112,7 @@ namespace OpenNest.Engine.Fill
 
             // Compute vertical copy distance using bounding boxes as starting point,
             // then slide down to find true geometry distance.
-            var pairHeight = pair.Bbox.Length;
+            var pairHeight = pair.Bbox.Width;
             var testOffset = new Vector(0, pairHeight);
 
             // Create test parts for slide distance measurement.
@@ -218,7 +195,7 @@ namespace OpenNest.Engine.Fill
 
         private List<Part> AdjustColumn(PartPair pair, List<Part> column, CancellationToken token)
         {
-            var originalPairWidth = pair.Bbox.Width;
+            var originalPairWidth = pair.Bbox.Length;
 
             for (var iteration = 0; iteration < MaxIterations; iteration++)
             {
@@ -294,7 +271,7 @@ namespace OpenNest.Engine.Fill
             // Check if the pair got wider.
             var newBbox = PairBbox(p1, p2);
 
-            if (newBbox.Width > originalPairWidth + Tolerance.Epsilon)
+            if (newBbox.Length > originalPairWidth + Tolerance.Epsilon)
                 return null;
 
             return AnchorToWorkArea(p1, p2);

OpenNest.Engine/Fill/FillLinear.cs

@@ -11,7 +11,7 @@ namespace OpenNest.Engine.Fill
         public FillLinear(Box workArea, double partSpacing)
         {
             PartSpacing = partSpacing;
-            WorkArea = new Box(workArea.X, workArea.Y, workArea.Width, workArea.Length);
+            WorkArea = new Box(workArea.X, workArea.Y, workArea.Length, workArea.Width);
         }
 
         public Box WorkArea { get; }
@@ -41,7 +41,7 @@ namespace OpenNest.Engine.Fill
 
         private static double GetDimension(Box box, NestDirection direction)
         {
-            return direction == NestDirection.Horizontal ? box.Width : box.Length;
+            return direction == NestDirection.Horizontal ? box.Length : box.Width;
         }
 
         private static double GetStart(Box box, NestDirection direction)
@@ -119,10 +119,11 @@ namespace OpenNest.Engine.Fill
             var maxCopyDistance = FindMaxPairDistance(
                 patternA.Parts, boundaries, offset, pushDir, opposite, startOffset);
 
-            if (maxCopyDistance < Tolerance.Epsilon)
+            // The copy distance must be at least bboxDim + PartSpacing to prevent
-                return bboxDim + PartSpacing;
+            // bounding box overlap. Cross-pair slides can underestimate when the
-
+            // circumscribed polygon boundary overshoots the true arc, creating
-            return maxCopyDistance;
+            // spurious contacts between diagonal parts in adjacent copies.
+            return System.Math.Max(maxCopyDistance, bboxDim + PartSpacing);
         }
 
         /// <summary>

OpenNest.Engine/Fill/PairFiller.cs

@@ -45,9 +45,8 @@ namespace OpenNest.Engine.Fill
         }
 
         public PairFillResult Fill(NestItem item, Box workArea,
-            int plateNumber = 0,
             CancellationToken token = default,
-            IProgress<NestProgress> progress = null)
+            Action<List<Part>, string> reportProgress = null)
         {
             var bestFits = BestFitCache.GetOrCompute(
                 item.Drawing, plateSize.Length, plateSize.Width, partSpacing);
@@ -58,7 +57,7 @@ namespace OpenNest.Engine.Fill
 
             var targetCount = item.Quantity > 0 ? item.Quantity : 0;
             var parts = EvaluateCandidates(candidates, item.Drawing, workArea, targetCount,
-                plateNumber, token, progress);
+                token, reportProgress);
 
             return new PairFillResult { Parts = parts, BestFits = bestFits };
         }
@@ -66,7 +65,7 @@ namespace OpenNest.Engine.Fill
         private List<Part> EvaluateCandidates(
             List<BestFitResult> candidates, Drawing drawing,
             Box workArea, int targetCount,
-            int plateNumber, CancellationToken token, IProgress<NestProgress> progress)
+            CancellationToken token, Action<List<Part>, string> reportProgress)
         {
             List<Part> best = null;
             var sinceImproved = 0;
@@ -112,14 +111,8 @@ namespace OpenNest.Engine.Fill
                             sinceImproved++;
                         }
 
-                        NestEngineBase.ReportProgress(progress, new ProgressReport
+                        reportProgress?.Invoke(best,
-                        {
+                            $"Pairs: {batchStart + j + 1}/{candidates.Count} candidates, best = {best?.Count ?? 0} parts");
-                            Phase = NestPhase.Pairs,
-                            PlateNumber = plateNumber,
-                            Parts = best,
-                            WorkArea = workArea,
-                            Description = $"Pairs: {batchStart + j + 1}/{candidates.Count} candidates, best = {best?.Count ?? 0} parts",
-                        });
                     }
 
                     if (batchEnd >= EarlyExitMinTried && sinceImproved >= EarlyExitStaleLimit)
@@ -175,8 +168,8 @@ namespace OpenNest.Engine.Fill
             var newTop = remaining.Max(p => p.BoundingBox.Top);
 
             return new Box(workArea.X, workArea.Y,
-                workArea.Width,
+                workArea.Length,
-                System.Math.Min(newTop - workArea.Y, workArea.Length));
+                System.Math.Min(newTop - workArea.Y, workArea.Width));
         }
 
         private List<Part> EvaluateCandidate(BestFitResult candidate, Drawing drawing,
@@ -271,8 +264,8 @@ namespace OpenNest.Engine.Fill
             var topHeight = System.Math.Max(0, workArea.Top - gridBox.Top);
             var rightWidth = System.Math.Max(0, workArea.Right - gridBox.Right);
 
-            var topArea = workArea.Width * topHeight;
+            var topArea = workArea.Length * topHeight;
-            var rightArea = rightWidth * System.Math.Min(gridBox.Top - workArea.Y, workArea.Length);
+            var rightArea = rightWidth * System.Math.Min(gridBox.Top - workArea.Y, workArea.Width);
             var remnantArea = topArea + rightArea;
 
             return (int)(remnantArea * maxUtilization / partArea) + 1;
@@ -292,7 +285,7 @@ namespace OpenNest.Engine.Fill
             var topLength = workArea.Top - topY;
             if (topLength >= minDim)
             {
-                var topBox = new Box(workArea.X, topY, workArea.Width, topLength);
+                var topBox = new Box(workArea.X, topY, workArea.Length, topLength);
                 var parts = FillRemnantBox(drawing, topBox, token);
                 if (parts != null && parts.Count > (bestRemnant?.Count ?? 0))
                     bestRemnant = parts;
@@ -303,7 +296,7 @@ namespace OpenNest.Engine.Fill
             var rightWidth = workArea.Right - rightX;
             if (rightWidth >= minDim)
             {
-                var rightBox = new Box(rightX, workArea.Y, rightWidth, workArea.Length);
+                var rightBox = new Box(rightX, workArea.Y, rightWidth, workArea.Width);
                 var parts = FillRemnantBox(drawing, rightBox, token);
                 if (parts != null && parts.Count > (bestRemnant?.Count ?? 0))
                     bestRemnant = parts;

OpenNest.Engine/Fill/PartBoundary.cs

@@ -24,7 +24,7 @@ namespace OpenNest.Engine.Fill
         public PartBoundary(Part part, double spacing)
         {
             var entities = ConvertProgram.ToGeometry(part.Program)
-                .Where(e => e.Layer != SpecialLayers.Rapid)
+                .Where(e => e.Layer == SpecialLayers.Cut)
                 .ToList();
 
             var definedShape = new ShapeProfile(entities);

OpenNest.Engine/Fill/PatternTiler.cs

@@ -13,15 +13,15 @@ namespace OpenNest.Engine.Fill
             var cellBox = cell.GetBoundingBox();
             var halfSpacing = partSpacing / 2;
 
-            var cellWidth = cellBox.Width + partSpacing;
+            var cellW = cellBox.Width + partSpacing;
-            var cellHeight = cellBox.Length + partSpacing;
+            var cellL = cellBox.Length + partSpacing;
 
-            if (cellWidth <= 0 || cellHeight <= 0)
+            if (cellW <= 0 || cellL <= 0)
                 return new List<Part>();
 
-            // Size.Width = X-axis, Size.Length = Y-axis
+            // Width = Y axis, Length = X axis
-            var cols = (int)System.Math.Floor(plateSize.Width / cellWidth);
+            var cols = (int)System.Math.Floor(plateSize.Length / cellL);
-            var rows = (int)System.Math.Floor(plateSize.Length / cellHeight);
+            var rows = (int)System.Math.Floor(plateSize.Width / cellW);
 
             if (cols <= 0 || rows <= 0)
                 return new List<Part>();
@@ -37,7 +37,7 @@ namespace OpenNest.Engine.Fill
             {
                 for (var col = 0; col < cols; col++)
                 {
-                    var tileOffset = baseOffset + new Vector(col * cellWidth, row * cellHeight);
+                    var tileOffset = baseOffset + new Vector(col * cellL, row * cellW);
 
                     foreach (var part in cell)
                     {

OpenNest.Engine/Fill/RemnantFiller.cs

@@ -106,7 +106,7 @@ namespace OpenNest.Engine.Fill
                 // rectangular obstacle boundary. Without this, gaps between
                 // individual bounding boxes cause the next drawing to fill
                 // into inter-row spaces, producing an interleaved layout.
-                if (placed.Count > 1)
+                if (placed.Count > 2)
                     RemoveTopmostPart(placed);
 
                 allParts.AddRange(placed);

OpenNest.Engine/Fill/RemnantFinder.cs

@@ -304,10 +304,10 @@ namespace OpenNest.Engine.Fill
 
             // Edge extensions (priority 1).
             if (remnant.Right > envelope.Right + eps)
-                TryAdd(results, envelope.Right, remnant.Bottom, remnant.Right - envelope.Right, remnant.Length, 1, minDim);
+                TryAdd(results, envelope.Right, remnant.Bottom, remnant.Right - envelope.Right, remnant.Width, 1, minDim);
 
             if (remnant.Left < envelope.Left - eps)
-                TryAdd(results, remnant.Left, remnant.Bottom, envelope.Left - remnant.Left, remnant.Length, 1, minDim);
+                TryAdd(results, remnant.Left, remnant.Bottom, envelope.Left - remnant.Left, remnant.Width, 1, minDim);
 
             if (remnant.Top > envelope.Top + eps)
                 TryAdd(results, innerLeft, envelope.Top, innerRight - innerLeft, remnant.Top - envelope.Top, 1, minDim);

OpenNest.Engine/Fill/ShrinkFiller.cs

@@ -94,8 +94,8 @@ namespace OpenNest.Engine.Fill
         /// that fits roughly the target count. Scales the shrink axis proportionally
         /// from the full-area count down to the target, with margin.
         /// </summary>
-        private static Box EstimateStartBox(NestItem item, Box box,
+        internal static Box EstimateStartBox(NestItem item, Box box,
-            double spacing, ShrinkAxis axis, int targetCount)
+            double spacing, ShrinkAxis axis, int targetCount, double marginFactor = 1.3)
         {
             var bbox = item.Drawing.Program.BoundingBox();
             if (bbox.Width <= 0 || bbox.Length <= 0)
@@ -115,7 +115,7 @@ namespace OpenNest.Engine.Fill
 
             // Scale dimension proportionally: target/full * maxDim, with margin.
             var ratio = (double)targetCount / fullCount;
-            var estimate = maxDim * ratio * 1.3;
+            var estimate = maxDim * ratio * marginFactor;
             estimate = System.Math.Min(estimate, maxDim);
 
             if (estimate <= 0 || estimate >= maxDim)

OpenNest.Engine/Fill/StripeFiller.cs

@@ -95,14 +95,8 @@ public class StripeFiller
                 }
             }
 
-            NestEngineBase.ReportProgress(_context.Progress, new ProgressReport
+            _context.ReportProgress(bestParts,
-            {
+                $"{strategyName}: {i + 1}/{bestFits.Count} pairs, best = {bestParts?.Count ?? 0} parts");
-                Phase = NestPhase.Custom,
-                PlateNumber = _context.PlateNumber,
-                Parts = bestParts,
-                WorkArea = workArea,
-                Description = $"{strategyName}: {i + 1}/{bestFits.Count} pairs, best = {bestParts?.Count ?? 0} parts",
-            });
         }
 
         return bestParts ?? new List<Part>();
@@ -201,8 +195,8 @@ public class StripeFiller
     private static Box MakeStripeBox(Box workArea, double perpDim, NestDirection primaryAxis)
     {
         return primaryAxis == NestDirection.Horizontal
-            ? new Box(workArea.X, workArea.Y, workArea.Width, perpDim)
+            ? new Box(workArea.X, workArea.Y, workArea.Length, perpDim)
-            : new Box(workArea.X, workArea.Y, perpDim, workArea.Length);
+            : new Box(workArea.X, workArea.Y, perpDim, workArea.Width);
     }
 
     private List<Part> FillRemnant(List<Part> gridParts, NestDirection primaryAxis)
@@ -224,7 +218,7 @@ public class StripeFiller
             var remnantLength = workArea.Top - remnantY;
             if (remnantLength < minDim)
                 return null;
-            remnantBox = new Box(workArea.X, remnantY, workArea.Width, remnantLength);
+            remnantBox = new Box(workArea.X, remnantY, workArea.Length, remnantLength);
         }
         else
         {
@@ -232,7 +226,7 @@ public class StripeFiller
             var remnantWidth = workArea.Right - remnantX;
             if (remnantWidth < minDim)
                 return null;
-            remnantBox = new Box(remnantX, workArea.Y, remnantWidth, workArea.Length);
+            remnantBox = new Box(remnantX, workArea.Y, remnantWidth, workArea.Width);
         }
 
         Debug.WriteLine($"[StripeFiller] Remnant box: {remnantBox.Width:F2}x{remnantBox.Length:F2}");
@@ -324,7 +318,7 @@ public class StripeFiller
     {
         var box = FillHelpers.BuildRotatedPattern(patternParts, 0).BoundingBox;
         var span0 = GetDimension(box, axis);
-        var perpSpan0 = axis == NestDirection.Horizontal ? box.Length : box.Width;
+        var perpSpan0 = axis == NestDirection.Horizontal ? box.Width : box.Length;
 
         if (span0 <= perpSpan0)
             return 0;
@@ -388,7 +382,7 @@ public class StripeFiller
             var rotated = FillHelpers.BuildRotatedPattern(patternParts, currentAngle);
             var pairSpan = GetDimension(rotated.BoundingBox, axis);
             var perpDim = axis == NestDirection.Horizontal
-                ? rotated.BoundingBox.Length : rotated.BoundingBox.Width;
+                ? rotated.BoundingBox.Width : rotated.BoundingBox.Length;
 
             if (pairSpan + spacing <= 0)
                 break;
@@ -472,13 +466,13 @@ public class StripeFiller
     {
         var rotated = FillHelpers.BuildRotatedPattern(patternParts, angle);
         return axis == NestDirection.Horizontal
-            ? rotated.BoundingBox.Width
+            ? rotated.BoundingBox.Length
-            : rotated.BoundingBox.Length;
+            : rotated.BoundingBox.Width;
     }
 
     private static double GetDimension(Box box, NestDirection axis)
     {
-        return axis == NestDirection.Horizontal ? box.Width : box.Length;
+        return axis == NestDirection.Horizontal ? box.Length : box.Width;
     }
 
     private static bool HasOverlappingParts(List<Part> parts) =>

OpenNest.Engine/HorizontalRemnantEngine.cs

@@ -38,7 +38,7 @@ namespace OpenNest
             var bb = item.Drawing.Program.BoundingBox();
             var cos = System.Math.Abs(System.Math.Cos(angle));
             var sin = System.Math.Abs(System.Math.Sin(angle));
-            return bb.Length * cos + bb.Width * sin;
+            return bb.Width * cos + bb.Length * sin;
         }
     }
 }

OpenNest.Engine/LeadInAssigner.cs

@@ -0,0 +1,79 @@
+using OpenNest.CNC.CuttingStrategy;
+using OpenNest.Engine.Sequencing;
+using OpenNest.Geometry;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest.Engine
+{
+    public class LeadInAssigner
+    {
+        public IPartSequencer Sequencer { get; set; }
+
+        public void Assign(Plate plate)
+        {
+            var parameters = plate.CuttingParameters;
+            if (parameters == null)
+                return;
+
+            var sequenced = Sequencer.Sequence(plate.Parts.ToList(), plate);
+            var exitPoint = PlateHelper.GetExitPoint(plate);
+
+            // Pass 1: assign lead-ins to establish pierce points
+            var piercePoints = AssignPass(sequenced, parameters, exitPoint, nextPiercePoints: null);
+
+            // Pass 2: re-assign with knowledge of next part's start point
+            AssignPass(sequenced, parameters, exitPoint, nextPiercePoints: piercePoints);
+        }
+
+        private Vector[] AssignPass(List<SequencedPart> sequenced, CuttingParameters parameters,
+            Vector exitPoint, Vector[] nextPiercePoints)
+        {
+            var piercePoints = new Vector[sequenced.Count];
+            var currentPoint = exitPoint;
+
+            for (var i = 0; i < sequenced.Count; i++)
+            {
+                var part = sequenced[i].Part;
+
+                if (part.LeadInsLocked)
+                {
+                    piercePoints[i] = GetPiercePoint(part);
+                    currentPoint = part.Location;
+                    continue;
+                }
+
+                if (part.HasManualLeadIns)
+                    part.RemoveLeadIns();
+
+                var localApproach = currentPoint - part.Location;
+
+                if (nextPiercePoints != null && i + 1 < sequenced.Count)
+                {
+                    var nextStart = nextPiercePoints[i + 1] - part.Location;
+                    part.ApplyLeadIns(parameters, localApproach, nextStart);
+                }
+                else
+                {
+                    part.ApplyLeadIns(parameters, localApproach);
+                }
+
+                piercePoints[i] = GetPiercePoint(part);
+                currentPoint = part.Location;
+            }
+
+            return piercePoints;
+        }
+
+        private static Vector GetPiercePoint(Part part)
+        {
+            foreach (var code in part.Program.Codes)
+            {
+                if (code is CNC.Motion motion)
+                    return motion.EndPoint + part.Location;
+            }
+
+            return part.Location;
+        }
+    }
+}

OpenNest.Engine/ML/FeatureExtractor.cs

@@ -47,7 +47,7 @@ namespace OpenNest.Engine.ML
             {
                 Area = drawing.Area,
                 Convexity = drawing.Area / (hullArea > 0 ? hullArea : 1.0),
-                AspectRatio = bb.Width / (bb.Length > 0 ? bb.Length : 1.0),
+                AspectRatio = bb.Length / (bb.Width > 0 ? bb.Width : 1.0),
                 BoundingBoxFill = drawing.Area / (bb.Area() > 0 ? bb.Area() : 1.0),
                 VertexCount = polygon.Vertices.Count,
                 Bitmask = GenerateBitmask(polygon, 32)
@@ -72,8 +72,8 @@ namespace OpenNest.Engine.ML
                 for (int x = 0; x < size; x++)
                 {
                     // Map grid coordinate (0..size) to bounding box coordinate
-                    var px = bb.Left + (x + 0.5) * (bb.Width / size);
+                    var px = bb.Left + (x + 0.5) * (bb.Length / size);
-                    var py = bb.Bottom + (y + 0.5) * (bb.Length / size);
+                    var py = bb.Bottom + (y + 0.5) * (bb.Width / size);
 
                     if (polygon.ContainsPoint(new Vector(px, py)))
                     {

OpenNest.Engine/MultiPlateNester.cs

@@ -0,0 +1,661 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using OpenNest.Engine.Fill;
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest
+{
+    public enum PartClass
+    {
+        Large,
+        Medium,
+        Small,
+    }
+
+    public class MultiPlateNester
+    {
+        private readonly Plate _template;
+        private readonly List<PlateOption> _plateOptions;
+        private readonly List<PlateOption> _sortedOptions;
+        private readonly double _salvageRate;
+        private readonly double _minRemnantSize;
+        private readonly List<PlateResult> _platePool;
+        private readonly IProgress<NestProgress> _progress;
+        private readonly CancellationToken _token;
+        private readonly MultiPlateNestOptions _options;
+
+        private bool HasPlateOptions => _plateOptions != null && _plateOptions.Count > 0;
+
+        private MultiPlateNester(
+            MultiPlateNestOptions options,
+            List<Plate> existingPlates,
+            IProgress<NestProgress> progress, CancellationToken token)
+        {
+            _options = options;
+            _template = options.Template;
+            _plateOptions = options.PlateOptions;
+            _sortedOptions = options.PlateOptions?.OrderBy(o => o.Cost).ToList();
+            _salvageRate = options.SalvageRate;
+            _minRemnantSize = options.MinRemnantSize;
+            _platePool = InitializePlatePool(existingPlates);
+            _progress = progress;
+            _token = token;
+        }
+
+        // --- Static Utility Methods ---
+
+        public static bool FitsBounds(Box container, Box part)
+        {
+            var fitsNormal = container.Width >= part.Width - Tolerance.Epsilon
+                          && container.Length >= part.Length - Tolerance.Epsilon;
+            var fitsRotated = container.Width >= part.Length - Tolerance.Epsilon
+                           && container.Length >= part.Width - Tolerance.Epsilon;
+            return fitsNormal || fitsRotated;
+        }
+
+        public static List<NestItem> SortItems(List<NestItem> items, PartSortOrder sortOrder)
+        {
+            var withBounds = items.Select(i => (Item: i, Bounds: i.Drawing.Program.BoundingBox())).ToList();
+
+            switch (sortOrder)
+            {
+                case PartSortOrder.BoundingBoxArea:
+                    return withBounds
+                        .OrderByDescending(x => x.Bounds.Width * x.Bounds.Length)
+                        .Select(x => x.Item)
+                        .ToList();
+
+                case PartSortOrder.Size:
+                    return withBounds
+                        .OrderByDescending(x => System.Math.Max(x.Bounds.Width, x.Bounds.Length))
+                        .Select(x => x.Item)
+                        .ToList();
+
+                default:
+                    return items.ToList();
+            }
+        }
+
+        public static PartClass Classify(Box partBounds, Box workArea)
+        {
+            var halfWidth = workArea.Width / 2.0;
+            var halfLength = workArea.Length / 2.0;
+
+            if (partBounds.Width > halfWidth || partBounds.Length > halfLength)
+                return PartClass.Large;
+
+            var workAreaArea = workArea.Width * workArea.Length;
+            var partArea = partBounds.Width * partBounds.Length;
+
+            if (partArea > workAreaArea / 9.0)
+                return PartClass.Medium;
+
+            return PartClass.Small;
+        }
+
+        public static bool IsScrapRemnant(Box remnant, double minRemnantSize)
+        {
+            return remnant.Width < minRemnantSize && remnant.Length < minRemnantSize;
+        }
+
+        public static List<Box> FindRemnants(Plate plate, double minRemnantSize, bool scrapOnly)
+        {
+            var remnants = RemnantFinder.FromPlate(plate).FindRemnants();
+            return remnants.Where(r => IsScrapRemnant(r, minRemnantSize) == scrapOnly).ToList();
+        }
+
+        public struct UpgradeDecision
+        {
+            public bool ShouldUpgrade;
+            public double UpgradeCost;
+            public double NewPlateCost;
+        }
+
+        public static Plate CreatePlate(Plate template, List<PlateOption> options, Box minBounds)
+        {
+            var plate = new Plate(template.Size)
+            {
+                PartSpacing = template.PartSpacing,
+                Quadrant = template.Quadrant,
+            };
+            plate.EdgeSpacing = new Spacing
+            {
+                Left = template.EdgeSpacing.Left,
+                Right = template.EdgeSpacing.Right,
+                Top = template.EdgeSpacing.Top,
+                Bottom = template.EdgeSpacing.Bottom,
+            };
+
+            if (options == null || options.Count == 0 || minBounds == null)
+                return plate;
+
+            var sorted = options.OrderBy(o => o.Cost).ToList();
+
+            foreach (var option in sorted)
+            {
+                if (FitsBounds(OptionWorkArea(option, template), minBounds))
+                {
+                    plate.Size = new Size(option.Width, option.Length);
+                    return plate;
+                }
+            }
+
+            return plate;
+        }
+
+        public static UpgradeDecision EvaluateUpgradeVsNew(
+            PlateOption currentSize,
+            PlateOption upgradeSize,
+            PlateOption newPlateSize,
+            double salvageRate,
+            double estimatedNewPlateUtilization)
+        {
+            var upgradeCost = upgradeSize.Cost - currentSize.Cost;
+
+            var newPlateCost = newPlateSize.Cost;
+            var remnantFraction = 1.0 - estimatedNewPlateUtilization;
+            var salvageCredit = remnantFraction * newPlateSize.Cost * salvageRate;
+            var netNewCost = newPlateCost - salvageCredit;
+
+            return new UpgradeDecision
+            {
+                ShouldUpgrade = upgradeCost <= netNewCost,
+                UpgradeCost = upgradeCost,
+                NewPlateCost = netNewCost,
+            };
+        }
+
+        // --- Main Entry Point ---
+
+        public static MultiPlateResult Nest(
+            List<NestItem> items,
+            MultiPlateNestOptions options,
+            List<Plate> existingPlates = null,
+            IProgress<NestProgress> progress = null,
+            CancellationToken token = default)
+        {
+            var nester = new MultiPlateNester(options, existingPlates, progress, token);
+            return nester.Run(items, options.SortOrder, options.AllowPlateCreation);
+        }
+
+        // --- Private Helpers ---
+
+        private static Box OptionWorkArea(PlateOption option, Plate template)
+        {
+            var w = option.Width - template.EdgeSpacing.Left - template.EdgeSpacing.Right;
+            var h = option.Length - template.EdgeSpacing.Top - template.EdgeSpacing.Bottom;
+            return new Box(0, 0, w, h);
+        }
+
+        private static double ScoreZone(Box zone, Box partBounds)
+        {
+            if (!FitsBounds(zone, partBounds))
+                return -1;
+
+            var cols = (int)(zone.Width / partBounds.Width);
+            var rows = (int)(zone.Length / partBounds.Length);
+            var colsR = (int)(zone.Width / partBounds.Length);
+            var rowsR = (int)(zone.Length / partBounds.Width);
+            var estimatedCount = System.Math.Max(cols * rows, colsR * rowsR);
+
+            var utilization = (estimatedCount * partBounds.Width * partBounds.Length) / zone.Area();
+
+            var zoneAspect = zone.Width / zone.Length;
+            var partAspect = partBounds.Width / partBounds.Length;
+            var aspectMatch = System.Math.Min(zoneAspect, partAspect) / System.Math.Max(zoneAspect, partAspect);
+
+            return utilization * 0.7 + aspectMatch * 0.3;
+        }
+
+        private static void DecrementQuantity(NestItem item, int placed)
+        {
+            item.Quantity = System.Math.Max(0, item.Quantity - placed);
+        }
+
+        private int FillAndPlace(PlateResult pr, Box zone, NestItem item)
+        {
+            var engine = NestEngineRegistry.Create(pr.Plate);
+            var clonedItem = CloneItem(item);
+            var parts = engine.Fill(clonedItem, zone, _progress, _token);
+
+            if (parts.Count > 0)
+            {
+                pr.AddParts(parts);
+                DecrementQuantity(item, parts.Count);
+            }
+
+            return parts.Count;
+        }
+
+        private PlateResult CreateNewPlateResult(Plate plate)
+        {
+            var pr = new PlateResult { Plate = plate, IsNew = true };
+
+            if (HasPlateOptions)
+            {
+                pr.ChosenSize = _plateOptions.FirstOrDefault(o =>
+                    o.Width.IsEqualTo(plate.Size.Width) && o.Length.IsEqualTo(plate.Size.Length));
+            }
+
+            return pr;
+        }
+
+        private static NestItem CloneItem(NestItem item)
+        {
+            return new NestItem
+            {
+                Drawing = item.Drawing,
+                Priority = item.Priority,
+                Quantity = item.Quantity,
+                StepAngle = item.StepAngle,
+                RotationStart = item.RotationStart,
+                RotationEnd = item.RotationEnd,
+            };
+        }
+
+        private static List<PlateResult> InitializePlatePool(List<Plate> existingPlates)
+        {
+            var pool = new List<PlateResult>();
+
+            if (existingPlates != null)
+            {
+                foreach (var plate in existingPlates)
+                    pool.Add(new PlateResult { Plate = plate, IsNew = false });
+            }
+
+            return pool;
+        }
+
+        private bool TryWithUpgradedSize(PlateResult pr, PlateOption upgradeOption, Func<List<Box>, bool> tryFill)
+        {
+            var oldSize = pr.Plate.Size;
+            var oldChosenSize = pr.ChosenSize;
+
+            pr.Plate.Size = new Size(upgradeOption.Width, upgradeOption.Length);
+            pr.ChosenSize = upgradeOption;
+
+            var remnants = RemnantFinder.FromPlate(pr.Plate).FindRemnants();
+
+            if (remnants.Count > 0 && tryFill(remnants))
+                return true;
+
+            pr.Plate.Size = oldSize;
+            pr.ChosenSize = oldChosenSize;
+            return false;
+        }
+
+        private PlateOption FindSmallestFittingOption(Box partBounds)
+        {
+            return _sortedOptions?.FirstOrDefault(o => FitsBounds(OptionWorkArea(o, _template), partBounds));
+        }
+
+        // --- Orchestration ---
+
+        private MultiPlateResult Run(List<NestItem> items, PartSortOrder sortOrder, bool allowPlateCreation)
+        {
+            var result = new MultiPlateResult();
+
+            if (items == null || items.Count == 0)
+                return result;
+
+            var sorted = SortItems(items.Where(i => i.Quantity > 0).ToList(), sortOrder);
+
+            foreach (var item in sorted)
+            {
+                if (_token.IsCancellationRequested || item.Quantity <= 0)
+                    continue;
+
+                var bb = item.Drawing.Program.BoundingBox();
+
+                TryPlaceOnExistingPlates(item, bb);
+
+                var templateClass = Classify(bb, _template.WorkArea());
+
+                if (item.Quantity > 0 && allowPlateCreation && templateClass != PartClass.Small)
+                {
+                    PlaceOnNewPlates(item, bb);
+
+                    if (item.Quantity > 0 && HasPlateOptions)
+                        TryUpgradeOrNewPlate(item, bb);
+                }
+            }
+
+            var leftovers = sorted.Where(i => i.Quantity > 0).ToList();
+
+            if (leftovers.Count > 0 && allowPlateCreation && !_token.IsCancellationRequested)
+            {
+                PackIntoExistingRemnants(leftovers);
+                CreateSharedPlates(leftovers);
+            }
+
+            if (HasPlateOptions && !_token.IsCancellationRequested)
+                TryConsolidateTailPlates();
+
+            foreach (var item in sorted.Where(i => i.Quantity > 0))
+                result.UnplacedItems.Add(item);
+
+            result.Plates.AddRange(_platePool.Where(p => p.Parts.Count > 0 || p.IsNew));
+            return result;
+        }
+
+        private void PackIntoExistingRemnants(List<NestItem> leftovers)
+        {
+            foreach (var pr in _platePool)
+            {
+                if (_token.IsCancellationRequested)
+                    break;
+
+                var anyPlaced = true;
+                while (anyPlaced && !_token.IsCancellationRequested)
+                {
+                    anyPlaced = false;
+
+                    var remaining = leftovers.Where(i => i.Quantity > 0).ToList();
+                    if (remaining.Count == 0)
+                        break;
+
+                    var remnants = RemnantFinder.FromPlate(pr.Plate).FindRemnants();
+                    if (remnants.Count == 0)
+                        break;
+
+                    var engine = NestEngineRegistry.Create(pr.Plate);
+
+                    foreach (var remnant in remnants)
+                    {
+                        remaining = leftovers.Where(i => i.Quantity > 0).ToList();
+                        if (remaining.Count == 0)
+                            break;
+
+                        var cloned = remaining.Select(CloneItem).ToList();
+                        var parts = engine.PackArea(remnant, cloned, _progress, _token);
+
+                        if (parts.Count > 0)
+                        {
+                            pr.AddParts(parts);
+                            anyPlaced = true;
+
+                            foreach (var item in remaining)
+                            {
+                                var placed = parts.Count(p => p.BaseDrawing == item.Drawing);
+                                DecrementQuantity(item, placed);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void CreateSharedPlates(List<NestItem> leftovers)
+        {
+            leftovers.RemoveAll(i => i.Quantity <= 0);
+
+            while (leftovers.Count > 0 && !_token.IsCancellationRequested)
+            {
+                var plate = CreatePlate(_template, _plateOptions, null);
+                var pr = CreateNewPlateResult(plate);
+                var placedAny = false;
+
+                foreach (var item in leftovers)
+                {
+                    if (item.Quantity <= 0 || _token.IsCancellationRequested)
+                        continue;
+
+                    var remnants = !placedAny
+                        ? new List<Box> { plate.WorkArea() }
+                        : RemnantFinder.FromPlate(plate).FindRemnants();
+
+                    if (remnants.Count == 0)
+                        break;
+
+                    var engine = NestEngineRegistry.Create(plate);
+
+                    foreach (var remnant in remnants)
+                    {
+                        if (item.Quantity <= 0)
+                            break;
+
+                        var clonedItem = CloneItem(item);
+                        var parts = engine.Fill(clonedItem, remnant, _progress, _token);
+
+                        if (parts.Count > 0)
+                        {
+                            pr.AddParts(parts);
+                            DecrementQuantity(item, parts.Count);
+                            placedAny = true;
+                        }
+                    }
+                }
+
+                if (!placedAny)
+                    break;
+
+                _platePool.Add(pr);
+                leftovers.RemoveAll(i => i.Quantity <= 0);
+            }
+        }
+
+        private bool TryPlaceOnExistingPlates(NestItem item, Box partBounds)
+        {
+            var anyPlaced = false;
+            var remnantCache = new Dictionary<PlateResult, List<Box>>();
+            PlateResult lastModified = null;
+
+            while (item.Quantity > 0 && !_token.IsCancellationRequested)
+            {
+                PlateResult bestPlate = null;
+                Box bestZone = null;
+                var bestScore = double.MinValue;
+
+                foreach (var pr in _platePool)
+                {
+                    if (_token.IsCancellationRequested)
+                        break;
+
+                    if (pr == lastModified || !remnantCache.ContainsKey(pr))
+                    {
+                        var workArea = pr.Plate.WorkArea();
+                        var classification = Classify(partBounds, workArea);
+
+                        remnantCache[pr] = classification == PartClass.Small
+                            ? FindRemnants(pr.Plate, _minRemnantSize, scrapOnly: true)
+                            : FindRemnants(pr.Plate, _minRemnantSize, scrapOnly: false);
+                    }
+
+                    foreach (var zone in remnantCache[pr])
+                    {
+                        var score = ScoreZone(zone, partBounds);
+                        if (score > bestScore)
+                        {
+                            bestPlate = pr;
+                            bestZone = zone;
+                            bestScore = score;
+                        }
+                    }
+                }
+
+                if (bestPlate == null || bestZone == null)
+                    break;
+
+                if (FillAndPlace(bestPlate, bestZone, item) == 0)
+                    break;
+
+                lastModified = bestPlate;
+                anyPlaced = true;
+            }
+
+            return anyPlaced;
+        }
+
+        private bool PlaceOnNewPlates(NestItem item, Box partBounds)
+        {
+            var anyPlaced = false;
+
+            while (item.Quantity > 0 && !_token.IsCancellationRequested)
+            {
+                var plate = CreatePlate(_template, _plateOptions, partBounds);
+                var workArea = plate.WorkArea();
+
+                if (!FitsBounds(workArea, partBounds))
+                    break;
+
+                var pr = CreateNewPlateResult(plate);
+
+                if (FillAndPlace(pr, workArea, item) == 0)
+                    break;
+
+                _platePool.Add(pr);
+                anyPlaced = true;
+            }
+
+            return anyPlaced;
+        }
+
+        private bool TryUpgradeOrNewPlate(NestItem item, Box partBounds)
+        {
+            if (!HasPlateOptions)
+                return false;
+
+            foreach (var pr in _platePool.Where(p => p.IsNew && p.ChosenSize != null))
+            {
+                var currentOption = pr.ChosenSize;
+                var currentIdx = _sortedOptions.FindIndex(o =>
+                    o.Width.IsEqualTo(currentOption.Width) && o.Length.IsEqualTo(currentOption.Length));
+
+                if (currentIdx < 0 || currentIdx >= _sortedOptions.Count - 1)
+                    continue;
+
+                for (var i = currentIdx + 1; i < _sortedOptions.Count; i++)
+                {
+                    var upgradeOption = _sortedOptions[i];
+
+                    if (upgradeOption.Width < currentOption.Width - Tolerance.Epsilon
+                        || upgradeOption.Length < currentOption.Length - Tolerance.Epsilon)
+                        continue;
+
+                    var smallestNew = FindSmallestFittingOption(partBounds);
+
+                    if (smallestNew == null)
+                        continue;
+
+                    var utilEst = pr.Plate.Utilization();
+                    var decision = EvaluateUpgradeVsNew(currentOption, upgradeOption, smallestNew,
+                        _salvageRate, utilEst);
+
+                    if (decision.ShouldUpgrade)
+                    {
+                        var placed = TryWithUpgradedSize(pr, upgradeOption, remnants =>
+                        {
+                            foreach (var remnant in remnants)
+                            {
+                                if (FillAndPlace(pr, remnant, item) > 0)
+                                    return true;
+                            }
+                            return false;
+                        });
+
+                        if (placed)
+                            return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private void TryConsolidateTailPlates()
+        {
+            var consolidated = true;
+            while (consolidated)
+            {
+                consolidated = false;
+
+                var activePlates = _platePool.Where(p => p.Parts.Count > 0 && p.IsNew).ToList();
+                if (activePlates.Count < 2)
+                    return;
+
+                var donors = activePlates.OrderBy(p => p.Plate.Utilization()).ToList();
+
+                foreach (var donor in donors)
+                {
+                    if (donor.Parts.Count == 0)
+                        continue;
+
+                    var donorParts = donor.Parts.ToList();
+                    var absorbed = false;
+
+                    foreach (var target in activePlates)
+                    {
+                        if (target == donor || target.ChosenSize == null || target.Parts.Count == 0)
+                            continue;
+
+                        var currentOption = target.ChosenSize;
+
+                        foreach (var upgradeOption in _sortedOptions.Where(o =>
+                            o.Width >= currentOption.Width - Tolerance.Epsilon
+                            && o.Length >= currentOption.Length - Tolerance.Epsilon
+                            && (o.Width > currentOption.Width + Tolerance.Epsilon
+                                || o.Length > currentOption.Length + Tolerance.Epsilon)))
+                        {
+                            absorbed = TryWithUpgradedSize(target, upgradeOption, remnants =>
+                            {
+                                var engine = NestEngineRegistry.Create(target.Plate);
+                                var tempItems = donorParts
+                                    .GroupBy(p => p.BaseDrawing)
+                                    .Select(g => new NestItem
+                                    {
+                                        Drawing = g.Key,
+                                        Quantity = g.Count(),
+                                    })
+                                    .ToList();
+
+                                var totalPlaced = new List<Part>();
+                                foreach (var remnant in remnants)
+                                {
+                                    var placed = engine.PackArea(remnant, tempItems, _progress, _token);
+                                    totalPlaced.AddRange(placed);
+
+                                    foreach (var ti in tempItems)
+                                    {
+                                        var count = placed.Count(p => p.BaseDrawing == ti.Drawing);
+                                        ti.Quantity = System.Math.Max(0, ti.Quantity - count);
+                                    }
+
+                                    if (tempItems.All(ti => ti.Quantity <= 0))
+                                        break;
+                                }
+
+                                if (totalPlaced.Count >= donorParts.Count)
+                                {
+                                    target.AddParts(totalPlaced);
+
+                                    foreach (var p in donorParts)
+                                        donor.Plate.Parts.Remove(p);
+                                    donor.Parts.Clear();
+                                    _platePool.Remove(donor);
+                                    return true;
+                                }
+
+                                return false;
+                            });
+
+                            if (absorbed)
+                                break;
+                        }
+
+                        if (absorbed)
+                            break;
+                    }
+
+                    if (absorbed)
+                    {
+                        consolidated = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}

OpenNest.Engine/MultiPlateResult.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+
+namespace OpenNest
+{
+    public class MultiPlateNestOptions
+    {
+        public Plate Template { get; set; }
+        public List<PlateOption> PlateOptions { get; set; }
+        public double SalvageRate { get; set; } = 0.5;
+        public PartSortOrder SortOrder { get; set; } = PartSortOrder.BoundingBoxArea;
+        public double MinRemnantSize { get; set; } = 12.0;
+        public bool AllowPlateCreation { get; set; } = true;
+    }
+
+    public class MultiPlateResult
+    {
+        public List<PlateResult> Plates { get; set; } = new();
+        public List<NestItem> UnplacedItems { get; set; } = new();
+    }
+
+    public class PlateResult
+    {
+        public Plate Plate { get; set; }
+        public List<Part> Parts { get; set; } = new();
+        public PlateOption ChosenSize { get; set; }
+        public bool IsNew { get; set; }
+
+        public void AddParts(IList<Part> parts)
+        {
+            Plate.Parts.AddRange(parts);
+            Parts.AddRange(parts);
+        }
+    }
+}

OpenNest.Engine/NestEngineBase.cs

@@ -1,4 +1,5 @@
 using OpenNest.Engine;
+using OpenNest.Engine.BestFit;
 using OpenNest.Engine.Fill;
 using OpenNest.Engine.Strategies;
 using OpenNest.Geometry;
@@ -86,14 +87,16 @@ namespace OpenNest
             var workArea = Plate.WorkArea();
             var allParts = new List<Part>();
 
+            var plateArea = workArea.Width * workArea.Length;
+
             var fillItems = items
-                .Where(i => i.Quantity != 1)
+                .Where(i => ShouldFill(i, plateArea))
                 .OrderBy(i => i.Priority)
                 .ThenByDescending(i => i.Drawing.Area)
                 .ToList();
 
             var packItems = items
-                .Where(i => i.Quantity == 1)
+                .Where(i => !ShouldFill(i, plateArea))
                 .ToList();
 
             // Phase 1: Fill multi-quantity drawings using RemnantFiller.
@@ -129,19 +132,22 @@ namespace OpenNest
                 }
             }
 
-            // Phase 2: Pack single-quantity items into remaining space.
+            // Phase 2: Pack low-quantity items into remaining space.
+            // Separate qty=2 items — they'll be placed as best-fit pairs after packing.
             packItems = packItems.Where(i => i.Quantity > 0).ToList();
+            var pairItems = packItems.Where(i => i.Quantity == 2).ToList();
+            var regularPackItems = packItems.Where(i => i.Quantity != 2).ToList();
 
-            if (packItems.Count > 0 && workArea.Width > 0 && workArea.Length > 0
+            if (regularPackItems.Count > 0 && workArea.Width > 0 && workArea.Length > 0
                 && !token.IsCancellationRequested)
             {
-                var packParts = PackArea(workArea, packItems, progress, token);
+                var packParts = PackArea(workArea, regularPackItems, progress, token);
 
                 if (packParts.Count > 0)
                 {
                     allParts.AddRange(packParts);
 
-                    foreach (var item in packItems)
+                    foreach (var item in regularPackItems)
                     {
                         var placed = packParts.Count(p =>
                             p.BaseDrawing.Name == item.Drawing.Name);
@@ -150,6 +156,13 @@ namespace OpenNest
                 }
             }
 
+            // Phase 3: Place best-fit pairs for qty=2 items in remaining space.
+            if (pairItems.Count > 0 && !token.IsCancellationRequested)
+            {
+                var placed = PlaceBestFitPairs(pairItems, allParts, Plate.WorkArea());
+                allParts.AddRange(placed);
+            }
+
             // Compact placed parts toward the origin to close gaps.
             Compactor.Settle(allParts, Plate.WorkArea(), Plate.PartSpacing);
 
@@ -301,5 +314,101 @@ namespace OpenNest
             return false;
         }
 
+        /// <summary>
+        /// Places best-fit pairs for qty=2 items into remnant spaces around
+        /// already-placed parts. Returns all placed pair parts.
+        /// </summary>
+        private List<Part> PlaceBestFitPairs(List<NestItem> pairItems,
+            List<Part> existingParts, Box fullWorkArea)
+        {
+            var result = new List<Part>();
+            var obstacles = existingParts
+                .Select(p => p.BoundingBox.Offset(Plate.PartSpacing))
+                .ToList();
+            var finder = new RemnantFinder(fullWorkArea, obstacles);
+
+            foreach (var item in pairItems)
+            {
+                if (item.Quantity < 2) continue;
+
+                var bestFits = BestFitCache.GetOrCompute(
+                    item.Drawing, Plate.Size.Length, Plate.Size.Width, Plate.PartSpacing);
+
+                List<Part> bestPlacement = null;
+                Box bestTarget = null;
+
+                foreach (var fit in bestFits)
+                {
+                    if (!fit.Keep)
+                        continue;
+
+                    var parts = fit.BuildParts(item.Drawing);
+                    var pairBbox = ((IEnumerable<IBoundable>)parts).GetBoundingBox();
+                    var pairW = pairBbox.Width;
+                    var pairL = pairBbox.Length;
+                    var minDim = System.Math.Min(pairW, pairL);
+
+                    var remnants = finder.FindRemnants(minDim);
+
+                    foreach (var r in remnants)
+                    {
+                        if (pairW <= r.Width + Tolerance.Epsilon &&
+                            pairL <= r.Length + Tolerance.Epsilon)
+                        {
+                            var offset = r.Location - pairBbox.Location;
+                            foreach (var p in parts)
+                            {
+                                p.Offset(offset);
+                                p.UpdateBounds();
+                            }
+
+                            if (bestPlacement == null || IsBetterFill(parts, bestPlacement, r))
+                            {
+                                bestPlacement = parts;
+                                bestTarget = r;
+                            }
+                            break;
+                        }
+                    }
+                }
+
+                if (bestPlacement == null) continue;
+
+                result.AddRange(bestPlacement);
+                item.Quantity = 0;
+
+                var envelope = ((IEnumerable<IBoundable>)bestPlacement).GetBoundingBox();
+                finder.AddObstacle(envelope.Offset(Plate.PartSpacing));
+
+                Debug.WriteLine($"[Nest] Placed best-fit pair for {item.Drawing.Name} " +
+                    $"at ({bestTarget.X:F1},{bestTarget.Y:F1}), " +
+                    $"size {envelope.Width:F1}x{envelope.Length:F1}");
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Determines whether a drawing should use grid-fill (true) or bin-pack (false).
+        /// Low-quantity items whose total area is a small fraction of the plate are
+        /// better off being packed alongside other parts rather than filling first.
+        /// </summary>
+        private bool ShouldFill(NestItem item, double plateArea)
+        {
+            if (item.Quantity <= 1)
+                return false;
+
+            var bbox = item.Drawing.Program.BoundingBox();
+            var partArea = (bbox.Width + Plate.PartSpacing) * (bbox.Length + Plate.PartSpacing);
+            if (partArea <= 0)
+                return false;
+
+            var totalArea = partArea * item.Quantity;
+
+            // If the total area of all copies is less than 10% of the plate,
+            // packing produces better results than grid-filling.
+            return totalArea >= plateArea * 0.1;
+        }
+
     }
 }

OpenNest.Engine/PartSortOrder.cs

@@ -0,0 +1,8 @@
+namespace OpenNest
+{
+    public enum PartSortOrder
+    {
+        BoundingBoxArea,
+        Size,
+    }
+}

OpenNest.Engine/PlateOptimizer.cs

@@ -0,0 +1,189 @@
+using OpenNest.Engine;
+using OpenNest.Engine.BestFit;
+using OpenNest.Geometry;
+using OpenNest.Math;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+
+namespace OpenNest
+{
+    public static class PlateOptimizer
+    {
+        public static PlateOptimizerResult Optimize(
+            List<NestItem> items,
+            List<PlateOption> plateOptions,
+            double salvageRate,
+            Plate templatePlate,
+            IProgress<NestProgress> progress = null,
+            CancellationToken token = default)
+        {
+            if (items == null || items.Count == 0 || plateOptions == null || plateOptions.Count == 0)
+                return null;
+
+            // Find the minimum dimension needed to fit the largest part,
+            // skipping items that are too large for every plate option.
+            var minPartWidth = 0.0;
+            var minPartLength = 0.0;
+            foreach (var item in items)
+            {
+                if (item.Quantity <= 0) continue;
+                var bb = item.Drawing.Program.BoundingBox();
+                var shortSide = System.Math.Min(bb.Width, bb.Length);
+                var longSide = System.Math.Max(bb.Width, bb.Length);
+
+                if (!plateOptions.Any(o => FitsPart(o, shortSide, longSide, templatePlate.EdgeSpacing)))
+                {
+                    Debug.WriteLine($"[PlateOptimizer] Skipping oversized item '{item.Drawing.Name}' " +
+                        $"({shortSide:F1}x{longSide:F1}) — does not fit any plate option");
+                    continue;
+                }
+
+                if (shortSide > minPartWidth) minPartWidth = shortSide;
+                if (longSide > minPartLength) minPartLength = longSide;
+            }
+
+            // Sort candidates by cost ascending — try cheapest first.
+            var candidates = plateOptions
+                .Where(o => FitsPart(o, minPartWidth, minPartLength, templatePlate.EdgeSpacing))
+                .OrderBy(o => o.Cost)
+                .ToList();
+
+            if (candidates.Count == 0)
+                return null;
+
+            // Pre-compute best fits for all candidate plate sizes at once.
+            // This runs the expensive GPU evaluation once on the largest plate
+            // and filters the results for each smaller size.
+            var plateSizes = candidates
+                .Select(o => (Width: o.Length, Height: o.Width))
+                .ToList();
+
+            foreach (var item in items)
+            {
+                if (item.Quantity <= 0) continue;
+                BestFitCache.ComputeForSizes(item.Drawing, templatePlate.PartSpacing, plateSizes);
+            }
+
+            PlateOptimizerResult best = null;
+
+            foreach (var option in candidates)
+            {
+                if (token.IsCancellationRequested)
+                    break;
+
+                var result = TryPlateSize(option, items, salvageRate, templatePlate, progress, token);
+                if (result == null)
+                    continue;
+
+                if (IsBetter(result, best))
+                    best = result;
+
+                // Early exit: when all items fit, larger plates can only have
+                // worse utilization and higher cost. With salvage < 100%, the
+                // remnant credit never offsets the extra plate cost, so skip.
+                if (salvageRate < 1.0)
+                {
+                    var allPlaced = items.All(i => i.Quantity <= 0 ||
+                        result.Parts.Count(p => p.BaseDrawing.Name == i.Drawing.Name) >= i.Quantity);
+                    if (allPlaced)
+                    {
+                        Debug.WriteLine($"[PlateOptimizer] Early exit: {option.Width}x{option.Length} placed all items");
+                        break;
+                    }
+                }
+            }
+
+            return best;
+        }
+
+        private static bool FitsPart(PlateOption option, double minWidth, double minLength, Spacing edgeSpacing)
+        {
+            var workW = option.Width - edgeSpacing.Left - edgeSpacing.Right;
+            var workL = option.Length - edgeSpacing.Top - edgeSpacing.Bottom;
+
+            // Part fits in either orientation.
+            var fitsNormal = workW >= minWidth - Tolerance.Epsilon && workL >= minLength - Tolerance.Epsilon;
+            var fitsRotated = workW >= minLength - Tolerance.Epsilon && workL >= minWidth - Tolerance.Epsilon;
+            return fitsNormal || fitsRotated;
+        }
+
+        private static PlateOptimizerResult TryPlateSize(
+            PlateOption option,
+            List<NestItem> items,
+            double salvageRate,
+            Plate templatePlate,
+            IProgress<NestProgress> progress,
+            CancellationToken token)
+        {
+            // Create a temporary plate with candidate size + settings from template.
+            var tempPlate = new Plate(option.Width, option.Length)
+            {
+                PartSpacing = templatePlate.PartSpacing,
+                EdgeSpacing = new Spacing
+                {
+                    Left = templatePlate.EdgeSpacing.Left,
+                    Right = templatePlate.EdgeSpacing.Right,
+                    Top = templatePlate.EdgeSpacing.Top,
+                    Bottom = templatePlate.EdgeSpacing.Bottom,
+                },
+            };
+
+            // Clone items so the dry run doesn't mutate originals.
+            var clonedItems = items.Select(i => new NestItem
+            {
+                Drawing = i.Drawing,  // share Drawing reference for BestFitCache compatibility
+                Priority = i.Priority,
+                Quantity = i.Quantity,
+                StepAngle = i.StepAngle,
+                RotationStart = i.RotationStart,
+                RotationEnd = i.RotationEnd,
+            }).ToList();
+
+            var engine = NestEngineRegistry.Create(tempPlate);
+            var parts = engine.Nest(clonedItems, progress, token);
+
+            if (parts == null || parts.Count == 0)
+                return null;
+
+            var workArea = tempPlate.WorkArea();
+            var plateArea = workArea.Width * workArea.Length;
+            var partsArea = 0.0;
+            foreach (var part in parts)
+                partsArea += part.BoundingBox.Area();
+
+            var remnantArea = plateArea - partsArea;
+            var costPerSqUnit = option.Cost / option.Area;
+            var netCost = option.Cost - (remnantArea * costPerSqUnit * salvageRate);
+
+            Debug.WriteLine($"[PlateOptimizer] {option.Width}x{option.Length} ${option.Cost}: " +
+                $"{parts.Count} parts, util={partsArea / plateArea:P1}, net=${netCost:F2}");
+
+            return new PlateOptimizerResult
+            {
+                Parts = parts,
+                ChosenSize = option,
+                NetCost = netCost,
+                Utilization = plateArea > 0 ? partsArea / plateArea : 0,
+            };
+        }
+
+        private static bool IsBetter(PlateOptimizerResult candidate, PlateOptimizerResult current)
+        {
+            if (current == null) return true;
+
+            // 1. More parts placed is always better.
+            if (candidate.Parts.Count != current.Parts.Count)
+                return candidate.Parts.Count > current.Parts.Count;
+
+            // 2. Lower net cost.
+            if (!candidate.NetCost.IsEqualTo(current.NetCost))
+                return candidate.NetCost < current.NetCost;
+
+            // 3. Higher utilization (tighter density) as tiebreak.
+            return candidate.Utilization > current.Utilization;
+        }
+    }
+}

OpenNest.Engine/PlateProcessingResult.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 
 namespace OpenNest.Engine
 {
-    public class PlateResult
+    public class PlateProcessingResult
     {
         public List<ProcessedPart> Parts { get; init; }
     }

OpenNest.Engine/PlateProcessor.cs

@@ -14,18 +14,41 @@ namespace OpenNest.Engine
         public ContourCuttingStrategy CuttingStrategy { get; set; }
         public IRapidPlanner RapidPlanner { get; set; }
 
-        public PlateResult Process(Plate plate)
+        public PlateProcessingResult Process(Plate plate)
         {
             var sequenced = Sequencer.Sequence(plate.Parts.ToList(), plate);
+            var exitPoint = PlateHelper.GetExitPoint(plate);
+
+            // Pass 1: process each part to collect pierce points
+            var piercePoints = new Vector[sequenced.Count];
+            var currentPoint = exitPoint;
+
+            for (var i = 0; i < sequenced.Count; i++)
+            {
+                var part = sequenced[i].Part;
+
+                if (!part.HasManualLeadIns && CuttingStrategy != null)
+                {
+                    var localApproach = ToPartLocal(currentPoint, part);
+                    var result = CuttingStrategy.Apply(part.Program, localApproach);
+                    piercePoints[i] = ToPlateSpace(GetProgramStartPoint(result.Program), part);
+                    currentPoint = ToPlateSpace(result.LastCutPoint, part);
+                }
+                else
+                {
+                    piercePoints[i] = ToPlateSpace(GetProgramStartPoint(part.Program), part);
+                    currentPoint = ToPlateSpace(GetProgramEndPoint(part.Program), part);
+                }
+            }
+
+            // Pass 2: re-process with next part's start point for perimeter lead-in refinement
             var results = new List<ProcessedPart>(sequenced.Count);
             var cutAreas = new List<Shape>();
-            var currentPoint = PlateHelper.GetExitPoint(plate);
+            currentPoint = exitPoint;
 
-            foreach (var sp in sequenced)
+            for (var i = 0; i < sequenced.Count; i++)
             {
-                var part = sp.Part;
+                var part = sequenced[i].Part;
-
-                // Compute approach point in part-local space
                 var localApproach = ToPartLocal(currentPoint, part);
 
                 Program processedProgram;
@@ -33,7 +56,18 @@ namespace OpenNest.Engine
 
                 if (!part.HasManualLeadIns && CuttingStrategy != null)
                 {
-                    var cuttingResult = CuttingStrategy.Apply(part.Program, localApproach);
+                    CuttingResult cuttingResult;
+
+                    if (i + 1 < sequenced.Count)
+                    {
+                        var nextStart = ToPartLocal(piercePoints[i + 1], part);
+                        cuttingResult = CuttingStrategy.Apply(part.Program, localApproach, nextStart);
+                    }
+                    else
+                    {
+                        cuttingResult = CuttingStrategy.Apply(part.Program, localApproach);
+                    }
+
                     processedProgram = cuttingResult.Program;
                     lastCutLocal = cuttingResult.LastCutPoint;
                 }
@@ -43,11 +77,9 @@ namespace OpenNest.Engine
                     lastCutLocal = GetProgramEndPoint(part.Program);
                 }
 
-                // Pierce point: program start point in plate space
+                var pierceLocal = GetProgramStartPoint(processedProgram);
-                var pierceLocal = GetProgramStartPoint(part.Program);
                 var piercePoint = ToPlateSpace(pierceLocal, part);
 
-                // Plan rapid from currentPoint to pierce point
                 var rapidPath = RapidPlanner.Plan(currentPoint, piercePoint, cutAreas);
 
                 results.Add(new ProcessedPart
@@ -57,16 +89,14 @@ namespace OpenNest.Engine
                     RapidPath = rapidPath
                 });
 
-                // Update cut areas with part perimeter
                 var perimeter = GetPartPerimeter(part);
                 if (perimeter != null)
                     cutAreas.Add(perimeter);
 
-                // Update current point to last cut point in plate space
                 currentPoint = ToPlateSpace(lastCutLocal, part);
             }
 
-            return new PlateResult { Parts = results };
+            return new PlateProcessingResult { Parts = results };
         }
 
         private static Vector ToPartLocal(Vector platePoint, Part part)

OpenNest.Engine/RectanglePacking/FillBestFit.cs

@@ -29,11 +29,15 @@ namespace OpenNest.RectanglePacking
                 Bin.Items.AddRange(bin1.Items);
             else
                 Bin.Items.AddRange(bin2.Items);
-        }
+        }   
+
 
         public override void Fill(Item item, int maxCount)
         {
-            throw new NotImplementedException();
+            Fill(item);
+
+            if (Bin.Items.Count > maxCount)
+                Bin.Items.RemoveRange(maxCount, Bin.Items.Count - maxCount);
         }
 
         private Bin BestFitHorizontal(Item item) => BestFitAxis(item, horizontal: true);
@@ -44,14 +48,18 @@ namespace OpenNest.RectanglePacking
         {
             var bin = Bin.Clone() as Bin;
 
-            var primarySize = horizontal ? item.Width : item.Length;
+            var primarySize = horizontal ? item.Length : item.Width;
-            var secondarySize = horizontal ? item.Length : item.Width;
+            var secondarySize = horizontal ? item.Width : item.Length;
-            var binPrimary = horizontal ? bin.Width : Bin.Length;
+            var binPrimary = horizontal ? bin.Length : Bin.Width;
-            var binSecondary = horizontal ? bin.Length : Bin.Width;
+            var binSecondary = horizontal ? bin.Width : Bin.Length;
 
-            if (!BestCombination.FindFrom2(primarySize, secondarySize, binPrimary, out var normalPrimary, out var rotatePrimary))
+            var combo = BestCombination.FindFrom2(primarySize, secondarySize, binPrimary);
+            if (!combo.Found)
                 return bin;
 
+            var normalPrimary = combo.Count1;
+            var rotatePrimary = combo.Count2;
+
             var normalSecondary = (int)System.Math.Floor((binSecondary + Tolerance.Epsilon) / secondarySize);
             var rotateSecondary = (int)System.Math.Floor((binSecondary + Tolerance.Epsilon) / primarySize);
 
@@ -67,9 +75,9 @@ namespace OpenNest.RectanglePacking
             bin.Items.AddRange(FillGrid(item, normalRows, normalCols, int.MaxValue));
 
             if (horizontal)
-                item.Location.X += item.Width * normalPrimary;
+                item.Location.X += item.Length * normalPrimary;
             else
-                item.Location.Y += item.Length * normalPrimary;
+                item.Location.Y += item.Width * normalPrimary;
 
             item.Rotate();
 

OpenNest.Engine/RectanglePacking/FillEngine.cs

@@ -27,8 +27,8 @@ namespace OpenNest.RectanglePacking
             {
                 for (var j = 0; j < innerCount; j++)
                 {
-                    var x = (columnMajor ? i : j) * item.Width + item.X;
+                    var x = (columnMajor ? i : j) * item.Length + item.X;
-                    var y = (columnMajor ? j : i) * item.Length + item.Y;
+                    var y = (columnMajor ? j : i) * item.Width + item.Y;
 
                     var clone = item.Clone() as Item;
                     clone.Location = new Vector(x, y);

OpenNest.Engine/RectanglePacking/FillNoRotation.cs

@@ -14,16 +14,16 @@ namespace OpenNest.RectanglePacking
 
         public override void Fill(Item item)
         {
-            var ycount = (int)System.Math.Floor((Bin.Length + Tolerance.Epsilon) / item.Length);
+            var ycount = (int)System.Math.Floor((Bin.Width + Tolerance.Epsilon) / item.Width);
-            var xcount = (int)System.Math.Floor((Bin.Width + Tolerance.Epsilon) / item.Width);
+            var xcount = (int)System.Math.Floor((Bin.Length + Tolerance.Epsilon) / item.Length);
 
             for (int i = 0; i < xcount; i++)
             {
-                var x = item.Width * i + Bin.X;
+                var x = item.Length * i + Bin.X;
 
                 for (int j = 0; j < ycount; j++)
                 {
-                    var y = item.Length * j + Bin.Y;
+                    var y = item.Width * j + Bin.Y;
 
                     var addedItem = item.Clone() as Item;
                     addedItem.Location = new Vector(x, y);
@@ -35,8 +35,8 @@ namespace OpenNest.RectanglePacking
 
         public override void Fill(Item item, int maxCount)
         {
-            var ycount = (int)System.Math.Floor((Bin.Length + Tolerance.Epsilon) / item.Length);
+            var ycount = (int)System.Math.Floor((Bin.Width + Tolerance.Epsilon) / item.Width);
-            var xcount = (int)System.Math.Floor((Bin.Width + Tolerance.Epsilon) / item.Width);
+            var xcount = (int)System.Math.Floor((Bin.Length + Tolerance.Epsilon) / item.Length);
             var count = ycount * xcount;
 
             if (count <= maxCount)

OpenNest.Engine/RectanglePacking/FillSpiral.cs

@@ -0,0 +1,83 @@
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest.RectanglePacking
+{
+    internal class FillSpiral : FillEngine
+    {
+        public Box CenterRemnant { get; private set; }
+
+        public FillSpiral(Bin bin)
+            : base(bin)
+        {
+        }
+
+        public override void Fill(Item item)
+        {
+            Fill(item, int.MaxValue);
+        }
+
+        public override void Fill(Item item, int maxCount)
+        {
+            if (item == null) return;
+
+            // Width = Y axis, Length = X axis
+            var comboY = BestCombination.FindFrom2(item.Width, item.Length, Bin.Width);
+            var comboX = BestCombination.FindFrom2(item.Length, item.Width, Bin.Length);
+
+            if (!comboY.Found || !comboX.Found)
+                return;
+
+            var q14size = new Size(
+                item.Width * comboY.Count1,
+                item.Length * comboX.Count1);
+            var q23size = new Size(
+                item.Length * comboY.Count2,
+                item.Width * comboX.Count2);
+
+            if ((q14size.Width > q23size.Width && q14size.Length > q23size.Length) ||
+                (q23size.Width > q14size.Width && q23size.Length > q14size.Length))
+                return; // cant do an efficient spiral fill
+
+            // Q1: normal orientation at bin origin
+            item.Location = Bin.Location;
+            var q1 = FillGrid(item, comboY.Count1, comboX.Count1, maxCount);
+            Bin.Items.AddRange(q1);
+
+            // Q2: rotated, above Q1
+            item.Rotate();
+            item.Location = new Vector(Bin.X, Bin.Y + q14size.Width);
+            var q2 = FillGrid(item, comboY.Count2, comboX.Count2, maxCount - Bin.Items.Count);
+            Bin.Items.AddRange(q2);
+
+            // Q3: rotated, right of Q1
+            item.Location = new Vector(Bin.X + q14size.Length, Bin.Y);
+            var q3 = FillGrid(item, comboY.Count2, comboX.Count2, maxCount - Bin.Items.Count);
+            Bin.Items.AddRange(q3);
+
+            // Q4: normal orientation, diagonal from Q1
+            item.Rotate();
+            item.Location = new Vector(
+                Bin.X + q23size.Length,
+                Bin.Y + q23size.Width);
+            var q4 = FillGrid(item, comboY.Count1, comboX.Count1, maxCount);
+            Bin.Items.AddRange(q4);
+
+            // Compute center remnant — the rectangular gap between the 4 quadrants
+            // Only valid when all 4 quadrants have items; otherwise the "center"
+            // overlaps an occupied quadrant and recursion never terminates.
+            var centerW = System.Math.Abs(q14size.Length - q23size.Length);
+            var centerH = System.Math.Abs(q14size.Width - q23size.Width);
+
+            if (comboY.Count1 > 0 && comboY.Count2 > 0 && comboX.Count1 > 0 && comboX.Count2 > 0
+                && centerW > Tolerance.Epsilon && centerH > Tolerance.Epsilon)
+            {
+                CenterRemnant = new Box(
+                    Bin.X + System.Math.Min(q14size.Length, q23size.Length),
+                    Bin.Y + System.Math.Min(q14size.Width, q23size.Width),
+                    centerW,
+                    centerH);
+            }
+        }
+    }
+}