feat(io): add Gravograph .CHR font reader with text-to-geometry

Add ChrFont, a reader for Gravograph .CHR engraving fonts, plus UI to
convert placed text into engraved geometry in the CAD converter.

The .CHR files are obfuscated with a single-byte XOR. Different
GravoStyle releases use different keys (0x2F in older versions, 0xCF in
the 7000 series, and others across the font library), so the key is
auto-detected from byte 1 of the file: the font name is ASCII stored as
UTF-16LE, so the high byte of its first character is 0x00 in plaintext
and the raw byte equals the key. This reads every font in a GravoStyle
install regardless of version, not just one hardcoded key.

UI: right-clicking a text item in EntityView raises TextConvertRequested;
CadConverterForm renders it via ChrFont with H/V alignment and adds the
result on an ENGRAVE layer.

Tests use Xunit.SkippableFact and a gitignored test-config.json so the
suite points at a local .CHR file without committing proprietary assets.

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

.gitignore

@@ -211,8 +211,8 @@ FakesAssemblies/
 .superpowers/
 docs/superpowers/
 
-# Documentation (manuals, templates, etc.)
-docs/
-
 # Launch settings
 **/Properties/launchSettings.json
+
+# Local test config (contains user-specific paths to proprietary test assets)
+OpenNest.Tests/test-config.json

CLAUDE.md

@@ -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`).
@@ -117,3 +119,4 @@ Always keep `README.md` and `CLAUDE.md` up to date when making changes that affe
 - `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);
         }
 

OpenNest.Console/Program.cs

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

OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs

@@ -1,5 +1,6 @@
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System;
 using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
@@ -11,6 +12,11 @@ namespace OpenNest.CNC.CuttingStrategy
         private record ContourEntry(Shape Shape, Vector Point, Entity Entity);
 
         public CuttingResult Apply(Program partProgram, Vector 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);
@@ -20,26 +26,60 @@ namespace OpenNest.CNC.CuttingStrategy
 
             var profile = new ShapeProfile(entities);
 
-            // Forward pass: sequence cutouts nearest-neighbor from perimeter
-            var perimeterPoint = profile.Perimeter.ClosestPointTo(approachPoint, out _);
-            var orderedCutouts = SequenceCutouts(profile.Cutouts, perimeterPoint);
+            // Start from the bounding box corner opposite the origin (max X, max Y)
+            var bbox = entities.GetBoundingBox();
+            var startCorner = new Vector(bbox.Right, bbox.Top);
+
+            // Initial pass: sequence cutouts from bbox corner
+            var seedPoint = startCorner;
+            var orderedCutouts = SequenceCutouts(profile.Cutouts, seedPoint);
             orderedCutouts.Reverse();
 
-            // Backward pass: walk from perimeter back through cutting order
-            // so each lead-in faces the next cutout to be cut, not the previous
-            var cutoutEntries = ResolveLeadInPoints(orderedCutouts, perimeterPoint);
+            var perimeterSeed = profile.Perimeter.ClosestPointTo(seedPoint, out _);
+            var cutoutEntries = ResolveLeadInPoints(orderedCutouts, perimeterSeed);
+
+            Vector perimeterPt;
+            Entity perimeterEntity;
+
+            if (!double.IsNaN(nextPartStart.X) && cutoutEntries.Count > 0)
+            {
+                // Iterate: each pass refines the perimeter lead-in which changes
+                // the internal sequence which changes the last cutout position
+                for (var iter = 0; iter < 3; iter++)
+                {
+                    var lastCutoutPt = cutoutEntries[cutoutEntries.Count - 1].Point;
+                    perimeterSeed = FindPerimeterIntersection(profile.Perimeter, lastCutoutPt, nextPartStart, out _);
+
+                    orderedCutouts = SequenceCutouts(profile.Cutouts, perimeterSeed);
+                    orderedCutouts.Reverse();
+                    cutoutEntries = ResolveLeadInPoints(orderedCutouts, perimeterSeed);
+                }
+
+                var finalLastCutout = cutoutEntries[cutoutEntries.Count - 1].Point;
+                perimeterPt = FindPerimeterIntersection(profile.Perimeter, finalLastCutout, nextPartStart, out perimeterEntity);
+            }
+            else
+            {
+                var perimeterRef = cutoutEntries.Count > 0 ? cutoutEntries[0].Point : approachPoint;
+                perimeterPt = profile.Perimeter.ClosestPointTo(perimeterRef, out perimeterEntity);
+            }
 
             var result = new Program(Mode.Absolute);
 
             EmitScribeContours(result, scribeEntities);
 
             foreach (var entry in cutoutEntries)
-                EmitContour(result, entry.Shape, entry.Point, entry.Entity);
+            {
+                if (!entry.Shape.IsClosed())
+                    EmitRawContour(result, entry.Shape);
+                else
+                    EmitContour(result, entry.Shape, entry.Point, entry.Entity);
+            }
 
-            // Perimeter last
-            var lastRefPoint = cutoutEntries.Count > 0 ? cutoutEntries[cutoutEntries.Count - 1].Point : approachPoint;
-            var perimeterPt = profile.Perimeter.ClosestPointTo(lastRefPoint, out var perimeterEntity);
-            EmitContour(result, profile.Perimeter, perimeterPt, perimeterEntity, ContourType.External);
+            if (!profile.Perimeter.IsClosed())
+                EmitRawContour(result, profile.Perimeter);
+            else
+                EmitContour(result, profile.Perimeter, perimeterPt, perimeterEntity, ContourType.External);
 
             result.Mode = Mode.Incremental;
 
@@ -67,10 +107,14 @@ namespace OpenNest.CNC.CuttingStrategy
             // Find the target shape that contains the clicked entity
             var (targetShape, matchedEntity) = FindTargetShape(profile, point, entity);
 
-            // Emit cutouts — only the target gets lead-in/out
+            // Emit cutouts — only the target gets lead-in/out (skip open contours)
             foreach (var cutout in profile.Cutouts)
             {
-                if (cutout == targetShape)
+                if (!cutout.IsClosed())
+                {
+                    EmitRawContour(result, cutout);
+                }
+                else if (cutout == targetShape)
                 {
                     var ct = DetectContourType(cutout);
                     EmitContour(result, cutout, point, matchedEntity, ct);
@@ -82,7 +126,11 @@ namespace OpenNest.CNC.CuttingStrategy
             }
 
             // Emit perimeter
-            if (profile.Perimeter == targetShape)
+            if (!profile.Perimeter.IsClosed())
+            {
+                EmitRawContour(result, profile.Perimeter);
+            }
+            else if (profile.Perimeter == targetShape)
             {
                 EmitContour(result, profile.Perimeter, point, matchedEntity, ContourType.External);
             }
@@ -187,6 +235,40 @@ namespace OpenNest.CNC.CuttingStrategy
             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);
@@ -197,16 +279,59 @@ namespace OpenNest.CNC.CuttingStrategy
             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);
+
+                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 reindexed = shape.ReindexAt(point, entity);
+            var reindexedShape = shape.ReindexAt(point, entity);
 
-            if (Parameters.TabsEnabled && Parameters.TabConfig != null)
-                reindexed = TrimShapeForTab(reindexed, point, Parameters.TabConfig.Size);
+            if (Parameters.TabsEnabled && Parameters.TabConfig != null && contourType == ContourType.External)
+                reindexedShape = TrimShapeForTab(reindexedShape, point, Parameters.TabConfig.Size);
 
-            program.Codes.AddRange(ConvertShapeToMoves(reindexed, point));
+            program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
             program.Codes.AddRange(leadOut.Generate(point, normal, winding));
         }
 
@@ -309,7 +434,12 @@ namespace OpenNest.CNC.CuttingStrategy
             if (shape.Entities.Count == 1 && shape.Entities[0] is Circle circle)
                 return circle.Rotation;
 
-            return shape.ToPolygon().RotationDirection();
+            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)

OpenNest.Core/CNC/CuttingStrategy/CuttingParameters.cs

@@ -23,6 +23,9 @@ namespace OpenNest.CNC.CuttingStrategy
 
         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; }
 

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

@@ -12,6 +12,8 @@ namespace OpenNest.CNC
 
         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)
@@ -87,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);
                 }
@@ -115,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;
 
@@ -137,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;
 
@@ -275,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;
@@ -290,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)
@@ -312,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)
@@ -345,8 +374,8 @@ namespace OpenNest.CNC
                             }
                             else
                             {
-                                endpt = arc.EndPoint;
-                                centerpt = arc.CenterPoint;
+                                endpt = frameOrigin + arc.EndPoint;
+                                centerpt = frameOrigin + arc.CenterPoint;
                             }
 
                             double minX1;
@@ -420,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)
@@ -460,6 +495,9 @@ namespace OpenNest.CNC
             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/RapidEnumerator.cs

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

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

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

OpenNest.Core/Converters/ConvertGeometry.cs

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

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

OpenNest.Core/Geometry/Arc.cs

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

OpenNest.Core/Geometry/Box.cs

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

OpenNest.Core/Geometry/Circle.cs

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

OpenNest.Core/Geometry/EllipseConverter.cs

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

OpenNest.Core/Geometry/Entity.cs

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

OpenNest.Core/Geometry/GeometryOptimizer.cs

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

OpenNest.Core/Geometry/Line.cs

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

OpenNest.Core/Geometry/Polygon.cs

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

OpenNest.Core/Geometry/Shape.cs

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

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

OpenNest.Core/Geometry/ShapeProfile.cs

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

OpenNest.Core/Geometry/SpatialQuery.cs

@@ -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;
-
-            // 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;
+            return DirectionalDistance(movingLines, 0, 0, stationaryLines, direction);
         }
 
         /// <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>();
-            for (int i = 0; i < movingLines.Count; i++)
-            {
-                movingVertices.Add(movingLines[i].pt1 + movingOffset);
-                movingVertices.Add(movingLines[i].pt2 + movingOffset);
-            }
+            var movingVertices = CollectVertices(movingLines, movingOffset);
 
-            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);
-
-            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();
+            var stationaryEdges = ToEdgeArray(stationaryLines);
+            SortEdgesForPruning(stationaryEdges, direction);
 
             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>();
-            for (int i = 0; i < stationaryLines.Count; i++)
-            {
-                stationaryVertices.Add(stationaryLines[i].pt1);
-                stationaryVertices.Add(stationaryLines[i].pt2);
-            }
+            var stationaryVertices = CollectVertices(stationaryLines, Vector.Zero);
 
-            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();
+            var movingEdges = ToEdgeArray(movingLines);
+            SortEdgesForPruning(movingEdges, opposite);
 
             foreach (var sv in stationaryVertices)
             {
@@ -253,15 +273,11 @@ namespace OpenNest.Geometry
         {
             var minDist = double.MaxValue;
 
-            // Extract unique vertices from moving edges.
-            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);
-            }
+            SortEdgesForPruning(stationaryEdges, direction);
 
             // 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>();
-            for (var i = 0; i < stationaryEdges.Length; i++)
-            {
-                stationaryVertices.Add(stationaryEdges[i].start + stationaryOffset);
-                stationaryVertices.Add(stationaryEdges[i].end + stationaryOffset);
-            }
+            SortEdgesForPruning(movingEdges, opposite);
+
+            var stationaryVertices = CollectVertices(stationaryEdges, stationaryOffset);
 
             foreach (var sv in stationaryVertices)
             {
@@ -293,49 +306,38 @@ namespace OpenNest.Geometry
             var minDist = double.MaxValue;
             var vx = vertex.X;
             var vy = vertex.Y;
+            var horizontal = IsHorizontalDirection(direction);
 
-            // Pruning: edges are sorted by their perpendicular min-coordinate in PartBoundary.
-            if (direction == PushDirection.Left || direction == PushDirection.Right)
+            // Pruning: edges are sorted by their perpendicular min-coordinate.
+            // For horizontal push, prune by Y range; for vertical push, prune by X range.
+            for (var i = 0; i < edges.Length; i++)
             {
-                for (var i = 0; i < edges.Length; i++)
+                var e1 = edges[i].start + edgeOffset;
+                var e2 = edges[i].end + edgeOffset;
+
+                double perpValue, edgeMin, edgeMax;
+                if (horizontal)
                 {
-                    var e1 = edges[i].start + edgeOffset;
-                    var e2 = edges[i].end + edgeOffset;
-
-                    var minY = e1.Y < e2.Y ? e1.Y : e2.Y;
-                    var maxY = e1.Y > e2.Y ? e1.Y : e2.Y;
-
-                    // Since edges are sorted by minY, if vy < minY, then vy < all subsequent minY.
-                    if (vy < minY - Tolerance.Epsilon)
-                        break;
-
-                    if (vy > maxY + Tolerance.Epsilon)
-                        continue;
-
-                    var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction);
-                    if (d < minDist) minDist = d;
+                    perpValue = vy;
+                    edgeMin = e1.Y < e2.Y ? e1.Y : e2.Y;
+                    edgeMax = e1.Y > e2.Y ? e1.Y : e2.Y;
                 }
-            }
-            else // Up/Down
-            {
-                for (var i = 0; i < edges.Length; i++)
+                else
                 {
-                    var e1 = edges[i].start + edgeOffset;
-                    var e2 = edges[i].end + edgeOffset;
-
-                    var minX = e1.X < e2.X ? e1.X : e2.X;
-                    var maxX = e1.X > e2.X ? e1.X : e2.X;
-
-                    // Since edges are sorted by minX, if vx < minX, then vx < all subsequent minX.
-                    if (vx < minX - Tolerance.Epsilon)
-                        break;
-
-                    if (vx > maxX + Tolerance.Epsilon)
-                        continue;
-
-                    var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction);
-                    if (d < minDist) minDist = d;
+                    perpValue = vx;
+                    edgeMin = e1.X < e2.X ? e1.X : e2.X;
+                    edgeMax = e1.X > e2.X ? e1.X : e2.X;
                 }
+
+                // Since edges are sorted by edgeMin, if perpValue < edgeMin, all subsequent edges are also past.
+                if (perpValue < edgeMin - Tolerance.Epsilon)
+                    break;
+
+                if (perpValue > edgeMax + Tolerance.Epsilon)
+                    continue;
+
+                var d = RayEdgeDistance(vx, vy, e1.X, e1.Y, e2.X, e2.Y, direction);
+                if (d < minDist) minDist = d;
             }
 
             return minDist;
@@ -467,12 +469,7 @@ namespace OpenNest.Geometry
             var dirX = direction.X;
             var dirY = direction.Y;
 
-            var movingVertices = new HashSet<Vector>();
-            for (var i = 0; i < movingLines.Count; i++)
-            {
-                movingVertices.Add(movingLines[i].pt1);
-                movingVertices.Add(movingLines[i].pt2);
-            }
+            var movingVertices = CollectVertices(movingLines, Vector.Zero);
 
             foreach (var mv in movingVertices)
             {
@@ -487,12 +484,7 @@ namespace OpenNest.Geometry
             var oppX = -dirX;
             var oppY = -dirY;
 
-            var stationaryVertices = new HashSet<Vector>();
-            for (var i = 0; i < stationaryLines.Count; i++)
-            {
-                stationaryVertices.Add(stationaryLines[i].pt1);
-                stationaryVertices.Add(stationaryLines[i].pt2);
-            }
+            var stationaryVertices = CollectVertices(stationaryLines, Vector.Zero);
 
             foreach (var sv in stationaryVertices)
             {
@@ -507,6 +499,311 @@ 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 not Arc arc)
+                    continue;
+
+                var cx = arc.Center.X;
+                var cy = arc.Center.Y;
+                var r = arc.Radius;
+
+                for (var j = 0; j < lineEntities.Count; j++)
+                {
+                    if (lineEntities[j] is not Line line)
+                        continue;
+
+                    var p1x = line.pt1.X;
+                    var p1y = line.pt1.Y;
+                    var ex = line.pt2.X - p1x;
+                    var ey = line.pt2.Y - p1y;
+
+                    var det = ex * dirY - ey * dirX;
+                    if (System.Math.Abs(det) < Tolerance.Epsilon)
+                        continue;
+
+                    // The directional distance from an arc point at angle θ to the
+                    // line is t(θ) = [A + r·(ey·cosθ − ex·sinθ)] / det.
+                    // dt/dθ = 0 at θ = atan2(−ex, ey) and θ + π.
+                    var theta1 = Angle.NormalizeRad(System.Math.Atan2(-ex, ey));
+                    var theta2 = Angle.NormalizeRad(theta1 + System.Math.PI);
+
+                    for (var k = 0; k < 2; k++)
+                    {
+                        var theta = k == 0 ? theta1 : theta2;
+
+                        if (!Angle.IsBetweenRad(theta, arc.StartAngle, arc.EndAngle, arc.IsReversed))
+                            continue;
+
+                        var qx = cx + r * System.Math.Cos(theta);
+                        var qy = cy + r * System.Math.Sin(theta);
+
+                        var d = RayEdgeDistance(qx, qy, p1x, p1y, line.pt2.X, line.pt2.Y,
+                            dirX, dirY);
+                        if (d < minDist) { minDist = d; if (d <= 0) return 0; }
+                    }
+                }
+            }
+            return minDist;
+        }
+
+        private static double RayEntityDistance(
+            double vx, double vy, Entity entity, double dirX, double dirY)
+        {
+            if (entity is Line line)
+            {
+                return RayEdgeDistance(vx, vy,
+                    line.pt1.X, line.pt1.Y, line.pt2.X, line.pt2.Y,
+                    dirX, dirY);
+            }
+
+            if (entity is Arc arc)
+            {
+                return RayArcDistance(vx, vy,
+                    arc.Center.X, arc.Center.Y, arc.Radius,
+                    arc.StartAngle, arc.EndAngle, arc.IsReversed,
+                    dirX, dirY);
+            }
+
+            if (entity is Circle circle)
+            {
+                return RayCircleDistance(vx, vy,
+                    circle.Center.X, circle.Center.Y, circle.Radius,
+                    dirX, dirY);
+            }
+
+            return double.MaxValue;
+        }
+
+        private static Vector[] ExtractEntityVertices(List<Entity> entities)
+        {
+            var vertices = new HashSet<Vector>();
+
+            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/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/Fraction.cs

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

OpenNest.Core/Part.cs

@@ -62,10 +62,15 @@ namespace OpenNest
         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);
+            var result = strategy.Apply(Program, approachPoint, nextPartStart);
             Program = result.Program;
             CuttingParameters = parameters;
             HasManualLeadIns = true;
@@ -190,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>

OpenNest.Core/PartGeometry.cs

@@ -39,7 +39,105 @@ 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);
+
+            foreach (var entity in source)
+            {
+                var copy = entity.Clone();
+                copy.Offset(location);
+                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 +148,12 @@ namespace OpenNest
             AddOffsetLines(lines, profile.Perimeter.OffsetOutward(totalSpacing),
                 chordTolerance, part.Location);
 
-            foreach (var cutout in profile.Cutouts)
-                AddOffsetLines(lines, cutout.OffsetInward(totalSpacing),
-                    chordTolerance, part.Location);
+            if (!perimeterOnly)
+            {
+                foreach (var cutout in profile.Cutouts)
+                    AddOffsetLines(lines, cutout.OffsetInward(totalSpacing),
+                        chordTolerance, part.Location);
+            }
 
             return lines;
         }

OpenNest.Core/Plate.cs

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

OpenNest.Core/Shapes/CircleShape.cs

@@ -7,6 +7,13 @@ namespace OpenNest.Shapes
     {
         public double Diameter { get; set; }
 
+        public override string GenerateName() => $"Circle {Dim(Diameter)} Dia";
+
+        public override void SetPreviewDefaults()
+        {
+            Diameter = 8;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>

OpenNest.Core/Shapes/IsoscelesTriangleShape.cs

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

OpenNest.Core/Shapes/LShape.cs

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

OpenNest.Core/Shapes/NgonShape.cs

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

OpenNest.Core/Shapes/PipeFlangeShape.cs

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

OpenNest.Core/Shapes/PipeSizes.cs

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

OpenNest.Core/Shapes/PlateSizes.cs

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

OpenNest.Core/Shapes/RectangleShape.cs

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

OpenNest.Core/Shapes/RightTriangleShape.cs

@@ -8,6 +8,14 @@ namespace OpenNest.Shapes
         public double Width { get; set; }
         public double Height { get; set; }
 
+        public override string GenerateName() => $"Right Triangle {Dim(Width)}x{Dim(Height)}";
+
+        public override void SetPreviewDefaults()
+        {
+            Width = 8;
+            Height = 6;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>

OpenNest.Core/Shapes/RingShape.cs

@@ -8,6 +8,14 @@ namespace OpenNest.Shapes
         public double OuterDiameter { get; set; }
         public double InnerDiameter { get; set; }
 
+        public override string GenerateName() => $"Ring {Dim(OuterDiameter)}x{Dim(InnerDiameter)}";
+
+        public override void SetPreviewDefaults()
+        {
+            OuterDiameter = 10;
+            InnerDiameter = 6;
+        }
+
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>

OpenNest.Core/Shapes/RoundedRectangleShape.cs

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

OpenNest.Core/Shapes/ShapeDefinition.cs

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

OpenNest.Core/Shapes/TShape.cs

@@ -10,6 +10,16 @@ namespace OpenNest.Shapes
         public double StemWidth { get; set; }
         public double BarHeight { get; set; }
 
+        public override string GenerateName() => $"T {Dim(Width)}x{Dim(Height)}";
+
+        public override void SetPreviewDefaults()
+        {
+            Width = 10;
+            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,15 @@ namespace OpenNest.Shapes
         public double BottomWidth { get; set; }
         public double Height { get; set; }
 
+        public override string GenerateName() => $"Trapezoid {Dim(TopWidth)}x{Dim(BottomWidth)}x{Dim(Height)}";
+
+        public override void SetPreviewDefaults()
+        {
+            TopWidth = 6;
+            BottomWidth = 10;
+            Height = 6;
+        }
+
         public override Drawing GetDrawing()
         {
             var offset = (BottomWidth - TopWidth) / 2.0;

OpenNest.Core/Splitting/DrawingSplitter.cs

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

OpenNest.Engine/BestFit/BestFitCache.cs

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

OpenNest.Engine/BestFit/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/BestFitResult.cs

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

OpenNest.Engine/BestFit/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/NfpSlideStrategy.cs

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

OpenNest.Engine/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
-            var overlaps = CheckOverlap(part1, part2);
+            // Overlap check — perimeter vs perimeter
+            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 shapes2 = GetPartShapes(part2);
-
-            for (var i = 0; i < shapes1.Count; i++)
-            {
-                for (var j = 0; j < shapes2.Count; j++)
-                {
-                    List<Vector> pts;
-
-                    if (shapes1[i].Intersects(shapes2[j], out pts))
-                        return true;
-                }
-            }
-
-            return false;
+            var entities = ConvertProgram.ToGeometry(source.Program)
+                .Where(e => e.Layer != SpecialLayers.Rapid).ToList();
+            var profile = new ShapeProfile(entities);
+            var program = ConvertGeometry.ToProgram(profile.Perimeter);
+            return new Drawing(source.Name, program);
         }
 
-        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));
-            return shapes;
+            if (shapes.Count == 0) return null;
+            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);
-
-                foreach (var vertex in polygon.Vertices)
-                    points.Add(vertex);
+                points.AddRange(polygon.Vertices);
             }
 
             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 part2TemplateLines = PartGeometry.GetOffsetPartLines(part2Template, halfSpacing);
+            var part1Entities = PartGeometry.GetOffsetPerimeterEntities(part1, 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;
 
@@ -90,15 +90,18 @@ namespace OpenNest.Engine.BestFit
                 if (isHorizontalPush)
                 {
                     // Perpendicular sweep along Y → Width; push extent along X → Length
-                    perpMin = -(bbox2.Width + spacing);
-                    perpMax = bbox1.Width + bbox2.Width + spacing;
+                    // Trim to offsets where the parts overlap by at least 50%.
+                    var halfOverlap = bbox2.Width * 0.5;
+                    perpMin = -(halfOverlap - spacing);
+                    perpMax = bbox1.Width + halfOverlap + spacing;
                     pushStartOffset = bbox1.Length + bbox2.Length + spacing * 2;
                 }
                 else
                 {
                     // Perpendicular sweep along X → Length; push extent along Y → Width
-                    perpMin = -(bbox2.Length + spacing);
-                    perpMax = bbox1.Length + bbox2.Length + spacing;
+                    var halfOverlap = bbox2.Length * 0.5;
+                    perpMin = -(halfOverlap - spacing);
+                    perpMax = bbox1.Length + halfOverlap + spacing;
                     pushStartOffset = bbox1.Width + bbox2.Width + spacing * 2;
                 }
 

OpenNest.Engine/CanonicalFrame.cs

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

OpenNest.Engine/DefaultNestEngine.cs

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

OpenNest.Engine/Fill/Compactor.cs

@@ -1,6 +1,7 @@
 using OpenNest.Geometry;
 using System.Collections.Generic;
 using System.Linq;
+using OpenNest.Math;
 
 namespace OpenNest.Engine.Fill
 {
@@ -11,12 +12,10 @@ 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
-                .Where(p => !movingParts.Contains(p))
+                .Where(p => !movingParts.Contains(p) && !IntersectsAny(p, movingParts))
                 .ToList();
 
             return Push(movingParts, obstacleParts, plate.WorkArea(), plate.PartSpacing, direction);
@@ -28,7 +27,7 @@ namespace OpenNest.Engine.Fill
         public static double Push(List<Part> movingParts, Plate plate, double angle)
         {
             var obstacleParts = plate.Parts
-                .Where(p => !movingParts.Contains(p))
+                .Where(p => !movingParts.Contains(p) && !IntersectsAny(p, movingParts))
                 .ToList();
 
             var direction = new Vector(System.Math.Cos(angle), System.Math.Sin(angle));
@@ -44,7 +43,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 +60,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 +87,26 @@ namespace OpenNest.Engine.Fill
                     if (!SpatialQuery.PerpendicularOverlap(movingBox, obstacleBoxes[i], direction))
                         continue;
 
-                    movingLines ??= halfSpacing > 0
-                        ? PartGeometry.GetOffsetPartLines(moving, halfSpacing, direction, ChordTolerance)
-                        : PartGeometry.GetPartLines(moving, direction, ChordTolerance);
+                    movingEntities ??= halfSpacing > 0
+                        ? (needCutouts
+                            ? PartGeometry.GetOffsetPartEntities(moving, halfSpacing)
+                            : PartGeometry.GetOffsetPerimeterEntities(moving, halfSpacing))
+                        : (needCutouts
+                            ? PartGeometry.GetPartEntities(moving)
+                            : PartGeometry.GetPerimeterEntities(moving));
 
-                    obstacleLines[i] ??= halfSpacing > 0
-                        ? PartGeometry.GetOffsetPartLines(obstacleParts[i], halfSpacing, opposite, ChordTolerance)
-                        : PartGeometry.GetPartLines(obstacleParts[i], opposite, ChordTolerance);
+                    obstacleEntities[i] ??= halfSpacing > 0
+                        ? PartGeometry.GetOffsetPerimeterEntities(obstacleParts[i], halfSpacing)
+                        : PartGeometry.GetPerimeterEntities(obstacleParts[i]);
+
+                    var d = SpatialQuery.DirectionalDistance(movingEntities, obstacleEntities[i], direction);
+                    if (d <= Tolerance.Epsilon
+                        && partSpacing <= Tolerance.Epsilon
+                        && CanNudgeWithoutOverlap(moving, obstacleParts[i], direction))
+                    {
+                        continue;
+                    }
 
-                    var d = SpatialQuery.DirectionalDistance(movingLines, obstacleLines[i], direction);
                     if (d < distance)
                         distance = d;
                 }
@@ -101,6 +123,31 @@ namespace OpenNest.Engine.Fill
             return 0;
         }
 
+        private static bool IntersectsAny(Part candidate, List<Part> parts)
+        {
+            for (var i = 0; i < parts.Count; i++)
+            {
+                if (candidate.Intersects(parts[i], out _))
+                    return true;
+            }
+            return false;
+        }
+
+        private static bool CanNudgeWithoutOverlap(Part moving, Part obstacle, Vector direction)
+        {
+            var nudge = direction * (Tolerance.Epsilon * 10);
+
+            moving.Offset(nudge);
+            try
+            {
+                return !moving.Intersects(obstacle, out _);
+            }
+            finally
+            {
+                moving.Offset(-nudge);
+            }
+        }
+
         public static double Push(List<Part> movingParts, List<Part> obstacleParts,
             Box workArea, double partSpacing, PushDirection direction)
         {
@@ -116,7 +163,7 @@ namespace OpenNest.Engine.Fill
         public static double PushBoundingBox(List<Part> movingParts, Plate plate, PushDirection direction)
         {
             var obstacleParts = plate.Parts
-                .Where(p => !movingParts.Contains(p))
+                .Where(p => !movingParts.Contains(p) && !IntersectsAny(p, movingParts))
                 .ToList();
 
             return PushBoundingBox(movingParts, obstacleParts, plate.WorkArea(), plate.PartSpacing, direction);
@@ -157,7 +204,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/FillLinear.cs

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

OpenNest.Engine/HorizontalRemnantEngine.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using OpenNest.Engine;
-using OpenNest.Engine.BestFit;
 using OpenNest.Engine.Fill;
 using OpenNest.Geometry;
 using OpenNest.Math;
@@ -27,20 +26,6 @@ namespace OpenNest
 
         public override ShrinkAxis TrimAxis => ShrinkAxis.Length;
 
-        protected override BestFitResult SelectBestFitPair(List<BestFitResult> results)
-        {
-            BestFitResult best = null;
-
-            foreach (var r in results)
-            {
-                if (!r.Keep) continue;
-                if (best == null || r.BoundingHeight < best.BoundingHeight)
-                    best = r;
-            }
-
-            return best;
-        }
-
         public override List<double> BuildAngles(NestItem item, ClassificationResult classification, Box workArea)
         {
             var baseAngles = new List<double> { classification.PrimaryAngle, classification.PrimaryAngle + Angle.HalfPI };

OpenNest.Engine/LeadInAssigner.cs

@@ -1,5 +1,7 @@
+using OpenNest.CNC.CuttingStrategy;
 using OpenNest.Engine.Sequencing;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace OpenNest.Engine
@@ -15,14 +17,28 @@ namespace OpenNest.Engine
                 return;
 
             var sequenced = Sequencer.Sequence(plate.Parts.ToList(), plate);
-            var currentPoint = PlateHelper.GetExitPoint(plate);
+            var exitPoint = PlateHelper.GetExitPoint(plate);
 
-            foreach (var sp in sequenced)
+            // 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 = sp.Part;
+                var part = sequenced[i].Part;
 
                 if (part.LeadInsLocked)
                 {
+                    piercePoints[i] = GetPiercePoint(part);
                     currentPoint = part.Location;
                     continue;
                 }
@@ -31,10 +47,33 @@ namespace OpenNest.Engine
                     part.RemoveLeadIns();
 
                 var localApproach = currentPoint - part.Location;
-                part.ApplyLeadIns(parameters, localApproach);
 
+                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

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

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

@@ -56,11 +56,6 @@ namespace OpenNest
 
         protected FillPolicy BuildPolicy() => new FillPolicy(Comparer, PreferredDirection);
 
-        protected virtual BestFitResult SelectBestFitPair(List<BestFitResult> results)
-        {
-            return results.FirstOrDefault(r => r.Keep);
-        }
-
         // --- Virtual methods (side-effect-free, return parts) ---
 
         public virtual List<Part> Fill(NestItem item, Box workArea,
@@ -338,50 +333,95 @@ namespace OpenNest
 
                 var bestFits = BestFitCache.GetOrCompute(
                     item.Drawing, Plate.Size.Length, Plate.Size.Width, Plate.PartSpacing);
-                var bestFit = SelectBestFitPair(bestFits);
-                if (bestFit == null) continue;
 
-                var parts = bestFit.BuildParts(item.Drawing);
-                var pairBbox = ((IEnumerable<IBoundable>)parts).GetBoundingBox();
-                var pairW = pairBbox.Width;
-                var pairL = pairBbox.Length;
-                var minDim = System.Math.Min(pairW, pairL);
+                // BestFitCache stores pair coordinates in canonical frame. Build candidates
+                // from a canonical drawing copy so geometry and coords share a frame; rebind
+                // + un-rotate winning pair to the original drawing's frame before returning.
+                var canonicalDrawing = CanonicalFrame.AsCanonicalCopy(item.Drawing);
+                var sourceAngle = item.Drawing?.Source?.Angle ?? 0.0;
 
-                var remnants = finder.FindRemnants(minDim);
-                Box target = null;
+                List<Part> bestPlacement = null;
+                Box bestTarget = null;
 
-                foreach (var r in remnants)
+                foreach (var fit in bestFits)
                 {
-                    if (pairW <= r.Width + Tolerance.Epsilon &&
-                        pairL <= r.Length + Tolerance.Epsilon)
+                    if (!fit.Keep)
+                        continue;
+
+                    var parts = fit.BuildParts(canonicalDrawing);
+                    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)
                     {
-                        target = r;
-                        break;
+                        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 (target == null) continue;
+                if (bestPlacement == null) continue;
 
-                var offset = target.Location - pairBbox.Location;
-                foreach (var p in parts)
-                {
-                    p.Offset(offset);
-                    p.UpdateBounds();
-                }
+                // Rebind to the original drawing and compose sourceAngle onto rotation so the
+                // final placed parts sit in the user's visible frame.
+                bestPlacement = RebindPairToOriginal(bestPlacement, item.Drawing, sourceAngle);
 
-                result.AddRange(parts);
+                result.AddRange(bestPlacement);
                 item.Quantity = 0;
 
-                var envelope = ((IEnumerable<IBoundable>)parts).GetBoundingBox();
+                var envelope = ((IEnumerable<IBoundable>)bestPlacement).GetBoundingBox();
                 finder.AddObstacle(envelope.Offset(Plate.PartSpacing));
 
                 Debug.WriteLine($"[Nest] Placed best-fit pair for {item.Drawing.Name} " +
-                    $"at ({target.X:F1},{target.Y:F1}), size {pairW:F1}x{pairL:F1}");
+                    $"at ({bestTarget.X:F1},{bestTarget.Y:F1}), " +
+                    $"size {envelope.Width:F1}x{envelope.Length:F1}");
             }
 
             return result;
         }
 
+        /// <summary>
+        /// Rebinds each canonical-frame Part in the pair to the original Drawing at its current
+        /// world pose, then composes sourceAngle onto each via CanonicalFrame.FromCanonical so
+        /// the returned list is in the original drawing's visible frame. Mirrors
+        /// DefaultNestEngine.RebindAndUnCanonicalize.
+        /// </summary>
+        private static List<Part> RebindPairToOriginal(List<Part> parts, Drawing original, double sourceAngle)
+        {
+            if (parts == null || parts.Count == 0)
+                return parts;
+
+            for (var i = 0; i < parts.Count; i++)
+            {
+                var p = parts[i];
+                var rebound = Part.CreateAtOrigin(original, p.Rotation);
+                var delta = p.BoundingBox.Location - rebound.BoundingBox.Location;
+                rebound.Offset(delta);
+                rebound.UpdateBounds();
+                parts[i] = rebound;
+            }
+
+            return CanonicalFrame.FromCanonical(parts, sourceAngle);
+        }
+
         /// <summary>
         /// Determines whether a drawing should use grid-fill (true) or bin-pack (false).
         /// Low-quantity items whose total area is a small fraction of the plate are

OpenNest.Engine/PartClassifier.cs

@@ -64,8 +64,8 @@ namespace OpenNest.Engine
             var mbrArea = mbr.Area;
             var mbrPerimeter = 2 * (mbr.Width + mbr.Height);
 
-            // Store primary angle (negated to align MBR with axes, same as RotationAnalysis).
-            result.PrimaryAngle = -mbr.Angle;
+            // Share the single angle formula with CanonicalAngle (no duplicate MBR compute).
+            result.PrimaryAngle = CanonicalAngle.FromMbr(mbr);
 
             // Drawing perimeter for circularity and perimeter ratio.
             var drawingPerimeter = polygon.Perimeter();

OpenNest.Engine/PartSortOrder.cs

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

OpenNest.Engine/PlateOptimizer.cs

@@ -1,4 +1,5 @@
 using OpenNest.Engine;
+using OpenNest.Engine.BestFit;
 using OpenNest.Geometry;
 using OpenNest.Math;
 using System;
@@ -22,7 +23,8 @@ namespace OpenNest
             if (items == null || items.Count == 0 || plateOptions == null || plateOptions.Count == 0)
                 return null;
 
-            // Find the minimum dimension needed to fit the largest part.
+            // 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)
@@ -31,6 +33,14 @@ namespace OpenNest
                 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;
             }
@@ -44,6 +54,19 @@ namespace OpenNest
             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)
@@ -58,9 +81,10 @@ namespace OpenNest
                 if (IsBetter(result, best))
                     best = result;
 
-                // Early exit: when salvage is zero, cheapest plate that fits everything wins.
-                // With salvage > 0, larger plates may have lower net cost, so keep searching.
-                if (salvageRate <= 0)
+                // 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);
@@ -158,8 +182,8 @@ namespace OpenNest
             if (!candidate.NetCost.IsEqualTo(current.NetCost))
                 return candidate.NetCost < current.NetCost;
 
-            // 3. Smaller plate area as tiebreak.
-            return candidate.ChosenSize.Area < current.ChosenSize.Area;
+            // 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;
-
-                // Compute approach point in part-local space
+                var part = sequenced[i].Part;
                 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 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/Strategies/FillContext.cs

@@ -15,7 +15,7 @@ namespace OpenNest.Engine.Strategies
         public int PlateNumber { get; init; }
         public CancellationToken Token { get; init; }
         public IProgress<NestProgress> Progress { get; init; }
-        public FillPolicy Policy { get; init; }
+        public FillPolicy Policy { get; init; } = new FillPolicy(new DefaultFillComparer());
         public int MaxQuantity { get; init; }
         public PartType PartType { get; set; }
 

OpenNest.Engine/VerticalRemnantEngine.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using OpenNest.Engine;
-using OpenNest.Engine.BestFit;
 using OpenNest.Engine.Fill;
 using OpenNest.Geometry;
 using OpenNest.Math;
@@ -25,20 +24,6 @@ namespace OpenNest
 
         public override NestDirection? PreferredDirection => NestDirection.Horizontal;
 
-        protected override BestFitResult SelectBestFitPair(List<BestFitResult> results)
-        {
-            BestFitResult best = null;
-
-            foreach (var r in results)
-            {
-                if (!r.Keep) continue;
-                if (best == null || r.BoundingHeight < best.BoundingHeight)
-                    best = r;
-            }
-
-            return best;
-        }
-
         public override List<double> BuildAngles(NestItem item, ClassificationResult classification, Box workArea)
         {
             var baseAngles = new List<double> { classification.PrimaryAngle, classification.PrimaryAngle + Angle.HalfPI };

OpenNest.IO/Bending/SolidWorksBendDetector.cs

@@ -133,7 +133,7 @@ namespace OpenNest.IO.Bending
         {
             return document.Entities
                 .OfType<ACadSharp.Entities.Line>()
-                .Where(l => l.Layer?.Name == "BEND"
+                .Where(l => (l.Layer?.Name == "BEND" || l.Layer?.Name == "0")
                     && (l.LineType?.Name?.Contains("CENTER") == true
                         || l.LineType?.Name == "CENTERX2"))
                 .ToList();

OpenNest.IO/Bom/BomAnalyzer.cs

@@ -42,6 +42,11 @@ namespace OpenNest.IO.Bom
                     var nameWithoutExt = Path.GetFileNameWithoutExtension(file);
                     dxfFiles[nameWithoutExt] = file;
                 }
+                foreach (var file in Directory.GetFiles(dxfFolder, "*.dwg"))
+                {
+                    var nameWithoutExt = Path.GetFileNameWithoutExtension(file);
+                    dxfFiles.TryAdd(nameWithoutExt, file);
+                }
             }
 
             // Partition items into: skipped, unmatched, or matched (grouped)
@@ -57,8 +62,8 @@ namespace OpenNest.IO.Bom
 
                 var lookupName = item.FileName;
 
-                // Strip .dxf extension if the BOM includes it
-                if (lookupName.EndsWith(".dxf", StringComparison.OrdinalIgnoreCase))
+                if (lookupName.EndsWith(".dxf", StringComparison.OrdinalIgnoreCase)
+                    || lookupName.EndsWith(".dwg", StringComparison.OrdinalIgnoreCase))
                     lookupName = Path.GetFileNameWithoutExtension(lookupName);
 
                 if (!folderExists)

OpenNest.IO/CadImportOptions.cs

@@ -0,0 +1,39 @@
+namespace OpenNest.IO
+{
+    /// <summary>
+    /// Options controlling how <see cref="CadImporter"/> loads a CAD file
+    /// and builds a <see cref="Drawing"/>.
+    /// </summary>
+    public class CadImportOptions
+    {
+        /// <summary>
+        /// Detector name to use for bend detection. Null = auto-detect.
+        /// </summary>
+        public string BendDetectorName { get; set; }
+
+        /// <summary>
+        /// When false, skips bend detection entirely. Default true.
+        /// </summary>
+        public bool DetectBends { get; set; } = true;
+
+        /// <summary>
+        /// Override the drawing name. Null = filename without extension.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Required quantity on the produced drawing. Default 1.
+        /// </summary>
+        public int Quantity { get; set; } = 1;
+
+        /// <summary>
+        /// Customer name on the produced drawing. Default null.
+        /// </summary>
+        public string Customer { get; set; }
+
+        /// <summary>
+        /// Returns a default options instance.
+        /// </summary>
+        public static CadImportOptions Default => new CadImportOptions();
+    }
+}

OpenNest.IO/CadImportResult.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using ACadSharp;
+using OpenNest.Bending;
+using OpenNest.Geometry;
+
+namespace OpenNest.IO
+{
+    /// <summary>
+    /// Intermediate result of <see cref="CadImporter.Import"/>. Holds raw loaded
+    /// geometry and detected bends. Callers may mutate <see cref="Entities"/> and
+    /// <see cref="Bends"/> before passing to <see cref="CadImporter.BuildDrawing"/>.
+    /// </summary>
+    public class CadImportResult
+    {
+        /// <summary>
+        /// All entities loaded from the source file, including promoted bend
+        /// source entities. Mutable.
+        /// </summary>
+        public List<Entity> Entities { get; set; } = new List<Entity>();
+
+        /// <summary>
+        /// Bends detected during import. Mutable — callers may add, remove,
+        /// or replace entries before building the drawing.
+        /// </summary>
+        public List<Bend> Bends { get; set; } = new List<Bend>();
+
+        /// <summary>
+        /// Bounding box of <see cref="Entities"/> at import time. May be stale
+        /// if callers mutate <see cref="Entities"/>; recompute if needed.
+        /// </summary>
+        public Box Bounds { get; set; }
+
+        /// <summary>
+        /// Absolute path to the source file.
+        /// </summary>
+        public string SourcePath { get; set; }
+
+        /// <summary>
+        /// Default drawing name (filename without extension, unless overridden).
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The raw CAD document from the source file. Available for callers
+        /// that need access to non-geometry entities (e.g., text annotations).
+        /// </summary>
+        public CadDocument Document { get; set; }
+    }
+}

OpenNest.IO/CadImporter.cs

@@ -0,0 +1,179 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using OpenNest.Bending;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.IO.Bending;
+using OpenNest.Math;
+
+namespace OpenNest.IO
+{
+    /// <summary>
+    /// Shared service that converts a CAD source file into a fully-populated
+    /// <see cref="Drawing"/>. Used by the UI, console, MCP, API, and training
+    /// tools so all code paths produce identical drawings.
+    /// </summary>
+    public static class CadImporter
+    {
+        /// <summary>
+        /// Load a DXF file, run bend detection, and return a mutable result
+        /// ready for interactive editing or direct conversion to a Drawing.
+        /// </summary>
+        public static CadImportResult Import(string path, CadImportOptions options = null)
+        {
+            options ??= CadImportOptions.Default;
+
+            var dxf = Dxf.Import(path);
+
+            RemoveDuplicateArcs(dxf.Entities);
+            RemoveZeroSweepArcs(dxf.Entities);
+
+            var bends = new List<Bend>();
+            if (options.DetectBends && dxf.Document != null)
+            {
+                bends = options.BendDetectorName == null
+                    ? BendDetectorRegistry.AutoDetect(dxf.Document)
+                    : BendDetectorRegistry.GetByName(options.BendDetectorName)
+                        ?.DetectBends(dxf.Document)
+                      ?? new List<Bend>();
+            }
+
+            Bend.UpdateEtchEntities(dxf.Entities, bends);
+
+            return new CadImportResult
+            {
+                Entities = dxf.Entities,
+                Bends = bends,
+                Bounds = dxf.Entities.GetBoundingBox(),
+                SourcePath = path,
+                Name = options.Name ?? Path.GetFileNameWithoutExtension(path),
+                Document = dxf.Document,
+            };
+        }
+
+        /// <summary>
+        /// Convenience for headless callers: Import a file and build a Drawing
+        /// in a single call, using all loaded entities and detected bends.
+        /// </summary>
+        public static Drawing ImportDrawing(string path, CadImportOptions options = null)
+        {
+            options ??= CadImportOptions.Default;
+            var result = Import(path, options);
+            return BuildDrawing(
+                result,
+                result.Entities,
+                result.Bends,
+                options.Quantity,
+                options.Customer,
+                editedProgram: null);
+        }
+
+        /// <summary>
+        /// Build a fully-populated <see cref="Drawing"/> from an import result plus
+        /// the caller's current entity and bend state. UI callers pass the currently
+        /// visible subset; headless callers pass the full lists.
+        ///
+        /// The produced drawing has:
+        /// - Program generated from the visible entities, with its first rapid moved
+        ///   to the origin and the pierce location stored in Source.Offset
+        /// - SourceEntities containing all non-bend-source entities from the result
+        /// - SuppressedEntityIds containing entities whose layer or IsVisible is false
+        /// - Bends copied from the provided list
+        /// - Customer, Quantity, Source.Path from options / result
+        /// </summary>
+        /// <param name="result">Import result from <see cref="Import"/>.</param>
+        /// <param name="entities">
+        /// Entities to build the program from. Typically the currently visible subset.
+        /// </param>
+        /// <param name="bends">Bends to attach to the drawing.</param>
+        /// <param name="quantity">Required quantity.</param>
+        /// <param name="customer">Customer name, or null.</param>
+        /// <param name="editedProgram">
+        /// When non-null, replaces the generated program (used by the UI to honor
+        /// in-place G-code edits). Source.Offset is still populated from the
+        /// generated program so round-trips stay consistent.
+        /// </param>
+        public static Drawing BuildDrawing(
+            CadImportResult result,
+            IEnumerable<Entity> entities,
+            IEnumerable<Bend> bends,
+            int quantity,
+            string customer,
+            OpenNest.CNC.Program editedProgram)
+        {
+            var visible = entities as IList<Entity> ?? new List<Entity>(entities);
+            var bendList = bends as IList<Bend> ?? new List<Bend>(bends);
+
+            var normalized = ShapeProfile.NormalizeEntities(visible);
+            var pgm = ConvertGeometry.ToProgram(normalized);
+
+            var offset = Vector.Zero;
+            if (pgm != null && pgm.Codes.Count > 0 && pgm[0].Type == OpenNest.CNC.CodeType.RapidMove)
+            {
+                var rapid = (OpenNest.CNC.RapidMove)pgm[0];
+                offset = rapid.EndPoint;
+                pgm.Offset(-offset);
+            }
+
+            var drawing = new Drawing(result.Name)
+            {
+                Color = Drawing.GetNextColor(),
+                Customer = customer,
+            };
+            drawing.Source.Path = result.SourcePath;
+            drawing.Source.Offset = offset;
+            drawing.Quantity.Required = quantity;
+            drawing.Bends.AddRange(bendList);
+            drawing.Program = editedProgram ?? pgm;
+
+            var bendSources = new HashSet<Entity>(
+                bendList.Where(b => b.SourceEntity != null).Select(b => b.SourceEntity));
+
+            drawing.SourceEntities = result.Entities
+                .Where(e => !bendSources.Contains(e))
+                .ToList();
+
+            drawing.SuppressedEntityIds = new HashSet<System.Guid>(
+                drawing.SourceEntities
+                    .Where(e => !(e.Layer != null && e.Layer.IsVisible && e.IsVisible))
+                    .Select(e => e.Id));
+
+            return drawing;
+        }
+
+        internal static void RemoveZeroSweepArcs(List<Entity> entities)
+        {
+            entities.RemoveAll(e =>
+                e is Arc arc && arc.StartAngle.IsEqualTo(arc.EndAngle, Tolerance.ChainTolerance));
+        }
+
+        internal static void RemoveDuplicateArcs(List<Entity> entities)
+        {
+            var circles = entities.OfType<Circle>().ToList();
+            var arcs = entities.OfType<Arc>().ToList();
+            var arcsToRemove = new List<Arc>();
+
+            foreach (var arc in arcs)
+            {
+                foreach (var circle in circles)
+                {
+                    if (arc.Layer?.Name != circle.Layer?.Name)
+                        continue;
+
+                    if (!arc.Center.DistanceTo(circle.Center).IsEqualTo(0))
+                        continue;
+
+                    if (!arc.Radius.IsEqualTo(circle.Radius))
+                        continue;
+
+                    arcsToRemove.Add(arc);
+                    break;
+                }
+            }
+
+            foreach (var arc in arcsToRemove)
+                entities.Remove(arc);
+        }
+    }
+}

OpenNest.IO/ChrFont.cs

@@ -0,0 +1,369 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using OpenNest.Geometry;
+
+namespace OpenNest.IO
+{
+    public class ChrFont
+    {
+        private readonly Dictionary<int, ChrGlyph> glyphs = new();
+
+        public string Name { get; internal set; }
+        public string Version { get; internal set; }
+        public double CapHeight { get; internal set; } = 5000;
+
+        internal void AddGlyph(int charCode, ChrGlyph glyph)
+        {
+            glyphs[charCode] = glyph;
+        }
+
+        public bool HasGlyph(int charCode) => glyphs.ContainsKey(charCode);
+
+        public ChrGlyph GetGlyph(int charCode) =>
+            glyphs.TryGetValue(charCode, out var g) ? g : null;
+
+        public double MeasureTextWidth(string text, double height)
+        {
+            var scale = height / CapHeight;
+            double width = 0;
+            foreach (var ch in text)
+            {
+                var glyph = GetGlyph(ch);
+                if (glyph == null)
+                {
+                    var space = GetGlyph(' ');
+                    width += (space?.AdvanceWidth ?? CapHeight * 0.6) * scale;
+                    continue;
+                }
+                width += glyph.AdvanceWidth * scale;
+            }
+            return width;
+        }
+
+        public List<Entity> RenderText(string text, double height, Vector position, Layer layer = null)
+        {
+            var scale = height / CapHeight;
+            var entities = new List<Entity>();
+            var cursorX = position.X;
+
+            foreach (var ch in text)
+            {
+                var glyph = GetGlyph(ch);
+                if (glyph == null)
+                {
+                    var space = GetGlyph(' ');
+                    cursorX += (space?.AdvanceWidth ?? CapHeight * 0.6) * scale;
+                    continue;
+                }
+
+                var glyphEntities = glyph.ToEntities(scale, cursorX, position.Y, layer);
+                entities.AddRange(glyphEntities);
+                cursorX += glyph.AdvanceWidth * scale;
+            }
+
+            return entities;
+        }
+
+        public static ChrFont Read(string path, byte? xorKey = null)
+        {
+            var raw = File.ReadAllBytes(path);
+
+            // The whole file is obfuscated with a single-byte XOR. Different
+            // GravoStyle versions use different keys (0x2F in older releases,
+            // 0xCF in 7000-series). The font name at offset 0 is ASCII stored
+            // as UTF-16LE, so the high byte of its first character is 0x00 in
+            // plaintext — which means raw[1] is exactly the XOR key. Detect it
+            // from the file unless the caller forces a specific key.
+            var key = xorKey ?? (raw.Length > 1 ? raw[1] : (byte)0x2F);
+
+            var data = new byte[raw.Length];
+            for (var i = 0; i < raw.Length; i++)
+                data[i] = (byte)(raw[i] ^ key);
+
+            return Parse(data);
+        }
+
+        private static ChrFont Parse(byte[] data)
+        {
+            var font = new ChrFont();
+
+            font.Name = Encoding.Unicode.GetString(data, 0, 26).TrimEnd('\0').Trim();
+            font.Version = Encoding.ASCII.GetString(data, 26, 12).TrimEnd('\0').Trim();
+
+            var charTable = new List<(int charCode, int offset)>();
+            var i = 0x40;
+            while (i + 5 < data.Length)
+            {
+                var charCode = data[i] | (data[i + 1] << 8);
+                var offset = data[i + 2] | (data[i + 3] << 8) | (data[i + 4] << 16) | (data[i + 5] << 24);
+
+                if (charCode < 0x20 || offset == 0 || offset >= data.Length)
+                    break;
+
+                charTable.Add((charCode, offset));
+                i += 6;
+            }
+
+            for (var c = 0; c < charTable.Count; c++)
+            {
+                var (charCode, offset) = charTable[c];
+
+                var nextOffset = c + 1 < charTable.Count
+                    ? FindNextOffset(charTable, offset, data.Length)
+                    : data.Length;
+
+                var glyph = ParseGlyph(data, offset, nextOffset);
+                if (glyph != null)
+                    font.AddGlyph(charCode, glyph);
+            }
+
+            if (font.glyphs.Count > 0)
+            {
+                foreach (var g in font.glyphs.Values)
+                {
+                    if (g.CapHeight > 0)
+                    {
+                        font.CapHeight = g.CapHeight;
+                        break;
+                    }
+                }
+            }
+
+            return font;
+        }
+
+        private static int FindNextOffset(List<(int charCode, int offset)> table, int currentOffset, int fileLength)
+        {
+            var best = fileLength;
+            foreach (var (_, off) in table)
+            {
+                if (off > currentOffset && off < best)
+                    best = off;
+            }
+            return best;
+        }
+
+        private static ChrGlyph ParseGlyph(byte[] data, int offset, int endOffset)
+        {
+            if (offset + 92 > data.Length)
+                return null;
+
+            var glyph = new ChrGlyph();
+            glyph.CapHeight = ReadBE16(data, offset + 15 * 2);
+            var bearing = System.Math.Abs(ReadBE16(data, offset + 18 * 2));
+            glyph.AdvanceWidth = ReadBE16(data, offset + 22 * 2) + bearing;
+
+            var strokeStart = offset + 92;
+            var pos = strokeStart;
+            var currentStroke = new List<ChrStrokePoint>();
+
+            while (pos + 5 < endOffset)
+            {
+                var cmd = ReadBE16(data, pos);
+                var x = ReadBE16(data, pos + 2);
+                var y = ReadBE16(data, pos + 4);
+                pos += 6;
+
+                if (System.Math.Abs(x) > 15000 || System.Math.Abs(y) > 15000)
+                    break;
+
+                if (cmd < -1000)
+                    break;
+
+                var type = cmd switch
+                {
+                    1 => ChrPointType.Vertex,
+                    4 => ChrPointType.Control,
+                    5 => ChrPointType.EndPoint,
+                    _ => ChrPointType.Vertex,
+                };
+
+                currentStroke.Add(new ChrStrokePoint(type, x, y));
+
+                if (type == ChrPointType.EndPoint)
+                {
+                    if (currentStroke.Count > 0)
+                        glyph.Strokes.Add(currentStroke);
+                    currentStroke = new List<ChrStrokePoint>();
+                }
+            }
+
+            if (currentStroke.Count > 0)
+                glyph.Strokes.Add(currentStroke);
+
+            return glyph;
+        }
+
+        private static int ReadBE16(byte[] data, int offset)
+        {
+            var val = (data[offset] << 8) | data[offset + 1];
+            if (val > 32767) val -= 65536;
+            return val;
+        }
+    }
+
+    internal enum ChrPointType
+    {
+        Vertex,
+        Control,
+        EndPoint,
+    }
+
+    internal struct ChrStrokePoint
+    {
+        public ChrPointType Type;
+        public double X;
+        public double Y;
+
+        public ChrStrokePoint(ChrPointType type, double x, double y)
+        {
+            Type = type;
+            X = x;
+            Y = y;
+        }
+    }
+
+    public class ChrGlyph
+    {
+        internal readonly List<List<ChrStrokePoint>> Strokes = new();
+
+        public double AdvanceWidth { get; internal set; }
+        public double CapHeight { get; internal set; }
+
+        private const int ArcSamples = 16;
+
+        public List<Entity> ToEntities(double scale, double offsetX, double offsetY, Layer layer = null)
+        {
+            var entities = new List<Entity>();
+            layer ??= Layer.Default;
+
+            foreach (var stroke in Strokes)
+            {
+                if (stroke.Count < 2) continue;
+
+                var segments = BuildSegments(stroke);
+                foreach (var seg in segments)
+                {
+                    if (seg.Points.Count < 2) continue;
+
+                    var scaled = new List<Vector>(seg.Points.Count);
+                    foreach (var pt in seg.Points)
+                        scaled.Add(new Vector(pt.X * scale + offsetX, pt.Y * scale + offsetY));
+
+                    var converted = PointsToLines(scaled);
+
+                    foreach (var e in converted)
+                    {
+                        e.Layer = layer;
+                        entities.Add(e);
+                    }
+                }
+            }
+
+            return entities;
+        }
+
+        private static List<Entity> PointsToLines(List<Vector> points)
+        {
+            var entities = new List<Entity>();
+            for (var i = 0; i < points.Count - 1; i++)
+            {
+                if (points[i].DistanceTo(points[i + 1]) < 0.001)
+                    continue;
+                entities.Add(new Line(points[i], points[i + 1]));
+            }
+            return entities;
+        }
+
+        private static List<StrokeSegment> BuildSegments(List<ChrStrokePoint> stroke)
+        {
+            var segments = new List<StrokeSegment>();
+            var current = new StrokeSegment();
+
+            var i = 0;
+            while (i < stroke.Count)
+            {
+                var pt = stroke[i];
+
+                if (pt.Type == ChrPointType.Vertex || pt.Type == ChrPointType.EndPoint)
+                {
+                    if (i + 1 < stroke.Count && stroke[i + 1].Type == ChrPointType.Control)
+                    {
+                        var p0 = new Vector(pt.X, pt.Y);
+                        var pMid = new Vector(stroke[i + 1].X, stroke[i + 1].Y);
+                        var p2End = i + 2 < stroke.Count ? stroke[i + 2] : stroke[i + 1];
+                        var p1 = new Vector(p2End.X, p2End.Y);
+
+                        SampleCircularArc(current.Points, p0, pMid, p1, ArcSamples);
+                        current.HasCurves = true;
+                        i += 2;
+                    }
+                    else
+                    {
+                        current.Points.Add(new Vector(pt.X, pt.Y));
+                        i++;
+                    }
+                }
+                else
+                {
+                    i++;
+                }
+            }
+
+            if (current.Points.Count >= 2)
+                segments.Add(current);
+
+            return segments;
+        }
+
+        private class StrokeSegment
+        {
+            public readonly List<Vector> Points = new();
+            public bool HasCurves;
+        }
+
+        private static void SampleCircularArc(List<Vector> output, Vector p0, Vector pMid, Vector p1, int samples)
+        {
+            if (output.Count == 0 || output[^1].DistanceTo(p0) > 0.01)
+                output.Add(p0);
+
+            double ax = p0.X, ay = p0.Y;
+            double bx = pMid.X, by = pMid.Y;
+            double cx = p1.X, cy = p1.Y;
+
+            var d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+
+            if (System.Math.Abs(d) < 1e-6)
+            {
+                output.Add(pMid);
+                output.Add(p1);
+                return;
+            }
+
+            var ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d;
+            var uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d;
+            var radius = System.Math.Sqrt((ax - ux) * (ax - ux) + (ay - uy) * (ay - uy));
+
+            var a0 = System.Math.Atan2(ay - uy, ax - ux);
+            var am = System.Math.Atan2(by - uy, bx - ux);
+            var a1 = System.Math.Atan2(cy - uy, cx - ux);
+
+            var ccwSweep = a1 - a0;
+            while (ccwSweep <= 0) ccwSweep += 2 * System.Math.PI;
+
+            var midRel = am - a0;
+            while (midRel < 0) midRel += 2 * System.Math.PI;
+
+            var sweep = midRel < ccwSweep ? ccwSweep : ccwSweep - 2 * System.Math.PI;
+
+            for (var i = 1; i <= samples; i++)
+            {
+                var t = (double)i / samples;
+                var angle = a0 + sweep * t;
+                output.Add(new Vector(ux + radius * System.Math.Cos(angle), uy + radius * System.Math.Sin(angle)));
+            }
+        }
+    }
+}

OpenNest.IO/Dxf.cs

@@ -0,0 +1,428 @@
+using ACadSharp;
+using ACadSharp.IO;
+using CSMath;
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using OpenNest.Math;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+
+namespace OpenNest.IO
+{
+    using AcadArc = ACadSharp.Entities.Arc;
+    using AcadCircle = ACadSharp.Entities.Circle;
+    using AcadLine = ACadSharp.Entities.Line;
+    using Layer = ACadSharp.Tables.Layer;
+
+    public static class Dxf
+    {
+        #region Import
+
+        /// <summary>
+        /// Imports a DXF file, returning both converted entities and the raw CadDocument
+        /// for bend detection. The CadDocument is NOT disposed — caller can use it for
+        /// additional analysis (e.g., MText extraction for bend notes).
+        /// </summary>
+        public static DxfImportResult Import(string path)
+        {
+            var doc = ReadDocument(path);
+
+            return new DxfImportResult
+            {
+                Entities = ConvertEntities(doc),
+                Document = doc
+            };
+        }
+
+        public static List<Entity> GetGeometry(string path)
+        {
+            try
+            {
+                var doc = ReadDocument(path);
+                return ConvertEntities(doc);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.Message);
+                return new List<Entity>();
+            }
+        }
+
+        public static List<Entity> GetGeometry(Stream stream)
+        {
+            try
+            {
+                using var reader = new DxfReader(stream);
+                var doc = reader.Read();
+                return ConvertEntities(doc);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.Message);
+                return new List<Entity>();
+            }
+        }
+
+        public static List<Entity> GetGeometry(string path, Func<string, bool> layerFilter)
+        {
+            try
+            {
+                using var reader = new DxfReader(path);
+                var doc = reader.Read();
+                return ConvertEntities(doc, layerFilter);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.Message);
+                return new List<Entity>();
+            }
+        }
+
+        public static List<Entity> GetGeometry(Stream stream, Func<string, bool> layerFilter)
+        {
+            try
+            {
+                using var reader = new DxfReader(stream);
+                var doc = reader.Read();
+                return ConvertEntities(doc, layerFilter);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.Message);
+                return new List<Entity>();
+            }
+        }
+
+        #endregion
+
+        #region Export
+
+        public static void ExportProgram(Program program, string path)
+        {
+            using var stream = File.Create(path);
+            ExportProgram(program, stream);
+        }
+
+        public static void ExportProgram(Program program, Stream stream)
+        {
+            var ctx = new ExportContext();
+            ctx.AddProgram(program);
+
+            using var writer = new DxfWriter(stream, ctx.Document, false);
+            writer.Write();
+        }
+
+        public static void ExportPlate(Plate plate, string path)
+        {
+            using var stream = File.Create(path);
+            ExportPlate(plate, stream);
+        }
+
+        public static void ExportPlate(Plate plate, Stream stream)
+        {
+            var ctx = new ExportContext();
+            ctx.AddPlateOutline(plate);
+
+            foreach (var part in plate.Parts)
+            {
+                var endpt = part.Location.ToAcadXYZ();
+                ctx.AddLine(ctx.CurPos, endpt, ctx.RapidLayer);
+                ctx.CurPos = part.Location.ToAcadXYZ();
+                ctx.AddProgram(part.Program);
+            }
+
+            using var writer = new DxfWriter(stream, ctx.Document, false);
+            writer.Write();
+        }
+
+        #endregion
+
+        #region Private
+
+        private static bool IsDwg(string path) =>
+            Path.GetExtension(path).Equals(".dwg", StringComparison.OrdinalIgnoreCase);
+
+        private static CadDocument ReadDocument(string path)
+        {
+            if (IsDwg(path))
+            {
+                using var reader = new DwgReader(path);
+                return reader.Read();
+            }
+            else
+            {
+                using var reader = new DxfReader(path);
+                return reader.Read();
+            }
+        }
+
+        private static List<Entity> ConvertEntities(CadDocument doc, Func<string, bool> layerFilter = null)
+        {
+            var entities = new List<Entity>();
+            var lines = new List<Line>();
+            var arcs = new List<Arc>();
+            var circles = new List<Circle>();
+            var filter = layerFilter ?? IsNonCutLayer;
+
+            foreach (var entity in doc.Entities)
+            {
+                if (filter(entity.Layer?.Name))
+                    continue;
+
+                switch (entity)
+                {
+                    case ACadSharp.Entities.Line line:
+                        lines.Add(line.ToOpenNest());
+                        break;
+
+                    case ACadSharp.Entities.Arc arc:
+                        arcs.Add(arc.ToOpenNest());
+                        break;
+
+                    case ACadSharp.Entities.Circle circle:
+                        circles.Add(circle.ToOpenNest());
+                        break;
+
+                    case ACadSharp.Entities.Spline spline:
+                        foreach (var e in spline.ToOpenNest())
+                        {
+                            if (e is Line l) lines.Add(l);
+                            else if (e is Arc a) arcs.Add(a);
+                        }
+                        break;
+
+                    case ACadSharp.Entities.LwPolyline lwPolyline:
+                        lines.AddRange(lwPolyline.ToOpenNest());
+                        break;
+
+                    case ACadSharp.Entities.Polyline polyline:
+                        lines.AddRange(polyline.ToOpenNest());
+                        break;
+
+                    case ACadSharp.Entities.Ellipse ellipse:
+                        foreach (var e in ellipse.ToOpenNest())
+                        {
+                            if (e is Line l) lines.Add(l);
+                            else if (e is Arc a) arcs.Add(a);
+                        }
+                        break;
+                }
+            }
+
+            GeometryOptimizer.Optimize(lines);
+            GeometryOptimizer.Optimize(arcs);
+            GeometryOptimizer.Deduplicate(circles);
+            GeometryOptimizer.Deduplicate(circles, arcs);
+
+            entities.AddRange(circles);
+            entities.AddRange(lines);
+            entities.AddRange(arcs);
+
+            return entities;
+        }
+
+        private static bool IsNonCutLayer(string layerName)
+        {
+            return string.Equals(layerName, "BEND", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(layerName, "ETCH", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private class ExportContext
+        {
+            public CadDocument Document { get; }
+            public XYZ CurPos { get; set; }
+            public Layer CutLayer { get; }
+            public Layer RapidLayer { get; }
+            public Layer PlateLayer { get; }
+
+            private Mode mode;
+
+            public ExportContext()
+            {
+                Document = new CadDocument();
+
+                CutLayer = new Layer("Cut") { Color = new Color(1) };
+                RapidLayer = new Layer("Rapid") { Color = new Color(5) };
+                PlateLayer = new Layer("Plate") { Color = new Color(4) };
+
+                Document.Layers.Add(CutLayer);
+                Document.Layers.Add(RapidLayer);
+                Document.Layers.Add(PlateLayer);
+            }
+
+            public void AddLine(XYZ start, XYZ end, Layer layer)
+            {
+                var ln = new AcadLine
+                {
+                    StartPoint = start,
+                    EndPoint = end,
+                    Layer = layer
+                };
+                Document.Entities.Add(ln);
+            }
+
+            public void AddPlateOutline(Plate plate)
+            {
+                XYZ pt1, pt2, pt3, pt4;
+
+                switch (plate.Quadrant)
+                {
+                    case 1:
+                        pt1 = new XYZ(0, 0, 0);
+                        pt2 = new XYZ(0, plate.Size.Width, 0);
+                        pt3 = new XYZ(plate.Size.Length, plate.Size.Width, 0);
+                        pt4 = new XYZ(plate.Size.Length, 0, 0);
+                        break;
+
+                    case 2:
+                        pt1 = new XYZ(0, 0, 0);
+                        pt2 = new XYZ(0, plate.Size.Width, 0);
+                        pt3 = new XYZ(-plate.Size.Length, plate.Size.Width, 0);
+                        pt4 = new XYZ(-plate.Size.Length, 0, 0);
+                        break;
+
+                    case 3:
+                        pt1 = new XYZ(0, 0, 0);
+                        pt2 = new XYZ(0, -plate.Size.Width, 0);
+                        pt3 = new XYZ(-plate.Size.Length, -plate.Size.Width, 0);
+                        pt4 = new XYZ(-plate.Size.Length, 0, 0);
+                        break;
+
+                    case 4:
+                        pt1 = new XYZ(0, 0, 0);
+                        pt2 = new XYZ(0, -plate.Size.Width, 0);
+                        pt3 = new XYZ(plate.Size.Length, -plate.Size.Width, 0);
+                        pt4 = new XYZ(plate.Size.Length, 0, 0);
+                        break;
+
+                    default:
+                        return;
+                }
+
+                AddLine(pt1, pt2, PlateLayer);
+                AddLine(pt2, pt3, PlateLayer);
+                AddLine(pt3, pt4, PlateLayer);
+                AddLine(pt4, pt1, PlateLayer);
+
+                var m1 = new XYZ(pt1.X + plate.EdgeSpacing.Left, pt1.Y + plate.EdgeSpacing.Bottom, 0);
+                var m2 = new XYZ(m1.X, pt2.Y - plate.EdgeSpacing.Top, 0);
+                var m3 = new XYZ(pt3.X - plate.EdgeSpacing.Right, m2.Y, 0);
+                var m4 = new XYZ(m3.X, m1.Y, 0);
+
+                AddLine(m1, m2, PlateLayer);
+                AddLine(m2, m3, PlateLayer);
+                AddLine(m3, m4, PlateLayer);
+                AddLine(m4, m1, PlateLayer);
+            }
+
+            public void AddProgram(Program program)
+            {
+                mode = program.Mode;
+
+                for (var i = 0; i < program.Length; ++i)
+                {
+                    var code = program[i];
+
+                    switch (code.Type)
+                    {
+                        case CodeType.ArcMove:
+                            AddArcMove((ArcMove)code);
+                            break;
+
+                        case CodeType.LinearMove:
+                            AddLinearMove((LinearMove)code);
+                            break;
+
+                        case CodeType.RapidMove:
+                            AddRapidMove((RapidMove)code);
+                            break;
+
+                        case CodeType.SubProgramCall:
+                            var tmpmode = mode;
+                            AddProgram(((SubProgramCall)code).Program);
+                            mode = tmpmode;
+                            break;
+                    }
+                }
+            }
+
+            private void AddLinearMove(LinearMove line)
+            {
+                var pt = line.EndPoint.ToAcadXYZ();
+
+                if (mode == Mode.Incremental)
+                    pt = new XYZ(pt.X + CurPos.X, pt.Y + CurPos.Y, 0);
+
+                AddLine(CurPos, pt, CutLayer);
+                CurPos = pt;
+            }
+
+            private void AddRapidMove(RapidMove rapid)
+            {
+                var pt = rapid.EndPoint.ToAcadXYZ();
+
+                if (mode == Mode.Incremental)
+                    pt = new XYZ(pt.X + CurPos.X, pt.Y + CurPos.Y, 0);
+
+                AddLine(CurPos, pt, RapidLayer);
+                CurPos = pt;
+            }
+
+            private void AddArcMove(ArcMove arc)
+            {
+                var center = arc.CenterPoint.ToAcadXYZ();
+                var endpt = arc.EndPoint.ToAcadXYZ();
+
+                if (mode == Mode.Incremental)
+                {
+                    endpt = new XYZ(endpt.X + CurPos.X, endpt.Y + CurPos.Y, 0);
+                    center = new XYZ(center.X + CurPos.X, center.Y + CurPos.Y, 0);
+                }
+
+                var startAngle = System.Math.Atan2(
+                    CurPos.Y - center.Y,
+                    CurPos.X - center.X);
+
+                var endAngle = System.Math.Atan2(
+                    endpt.Y - center.Y,
+                    endpt.X - center.X);
+
+                if (arc.Rotation == RotationType.CW)
+                    Generic.Swap(ref startAngle, ref endAngle);
+
+                var dx = endpt.X - center.X;
+                var dy = endpt.Y - center.Y;
+                var radius = System.Math.Sqrt(dx * dx + dy * dy);
+
+                if (startAngle.IsEqualTo(endAngle))
+                {
+                    var circle = new AcadCircle
+                    {
+                        Center = center,
+                        Radius = radius,
+                        Layer = CutLayer
+                    };
+                    Document.Entities.Add(circle);
+                }
+                else
+                {
+                    var acadArc = new AcadArc
+                    {
+                        Center = center,
+                        Radius = radius,
+                        StartAngle = startAngle,
+                        EndAngle = endAngle,
+                        Layer = CutLayer
+                    };
+                    Document.Entities.Add(acadArc);
+                }
+
+                CurPos = endpt;
+            }
+        }
+
+        #endregion
+    }
+}

OpenNest.IO/DxfExporter.cs

@@ -1,297 +0,0 @@
-using ACadSharp;
-using ACadSharp.IO;
-using CSMath;
-using OpenNest.CNC;
-using OpenNest.Math;
-using System.Diagnostics;
-using System.IO;
-
-namespace OpenNest.IO
-{
-    using AcadArc = ACadSharp.Entities.Arc;
-    using AcadCircle = ACadSharp.Entities.Circle;
-    using AcadLine = ACadSharp.Entities.Line;
-    using Layer = ACadSharp.Tables.Layer;
-
-    public class DxfExporter
-    {
-        private CadDocument doc;
-        private XYZ curpos;
-        private Mode mode;
-        private readonly Layer cutLayer;
-        private readonly Layer rapidLayer;
-        private readonly Layer plateLayer;
-
-        public DxfExporter()
-        {
-            doc = new CadDocument();
-
-            cutLayer = new Layer("Cut");
-            cutLayer.Color = new Color(1);
-
-            rapidLayer = new Layer("Rapid");
-            rapidLayer.Color = new Color(5);
-
-            plateLayer = new Layer("Plate");
-            plateLayer.Color = new Color(4);
-        }
-
-        public void ExportProgram(Program program, Stream stream)
-        {
-            doc = new CadDocument();
-            EnsureLayers();
-            AddProgram(program);
-            using (var writer = new DxfWriter(stream, doc, false))
-            {
-                writer.Write();
-            }
-        }
-
-        public bool ExportProgram(Program program, string path)
-        {
-            Stream stream = null;
-            var success = false;
-
-            try
-            {
-                stream = File.Create(path);
-                ExportProgram(program, stream);
-                success = true;
-            }
-            catch
-            {
-                Debug.Fail("DxfExporter.ExportProgram failed to write program to file: " + path);
-            }
-            finally
-            {
-                if (stream != null)
-                    stream.Close();
-            }
-
-            return success;
-        }
-
-        public void ExportPlate(Plate plate, Stream stream)
-        {
-            doc = new CadDocument();
-            EnsureLayers();
-            AddPlateOutline(plate);
-
-            foreach (var part in plate.Parts)
-            {
-                var endpt = part.Location.ToAcadXYZ();
-                AddLine(curpos, endpt, rapidLayer);
-                curpos = part.Location.ToAcadXYZ();
-                AddProgram(part.Program);
-            }
-
-            using (var writer = new DxfWriter(stream, doc, false))
-            {
-                writer.Write();
-            }
-        }
-
-        public bool ExportPlate(Plate plate, string path)
-        {
-            Stream stream = null;
-            var success = false;
-
-            try
-            {
-                stream = File.Create(path);
-                ExportPlate(plate, stream);
-                success = true;
-            }
-            catch
-            {
-                Debug.Fail("DxfExporter.ExportPlate failed to write plate to file: " + path);
-            }
-            finally
-            {
-                if (stream != null)
-                    stream.Close();
-            }
-
-            return success;
-        }
-
-        private void EnsureLayers()
-        {
-            doc.Layers.Add(cutLayer);
-            doc.Layers.Add(rapidLayer);
-            doc.Layers.Add(plateLayer);
-        }
-
-        private void AddLine(XYZ start, XYZ end, Layer layer)
-        {
-            var ln = new AcadLine();
-            ln.StartPoint = start;
-            ln.EndPoint = end;
-            ln.Layer = layer;
-            doc.Entities.Add(ln);
-        }
-
-        private void AddPlateOutline(Plate plate)
-        {
-            XYZ pt1;
-            XYZ pt2;
-            XYZ pt3;
-            XYZ pt4;
-
-            switch (plate.Quadrant)
-            {
-                case 1:
-                    pt1 = new XYZ(0, 0, 0);
-                    pt2 = new XYZ(0, plate.Size.Width, 0);
-                    pt3 = new XYZ(plate.Size.Length, plate.Size.Width, 0);
-                    pt4 = new XYZ(plate.Size.Length, 0, 0);
-                    break;
-
-                case 2:
-                    pt1 = new XYZ(0, 0, 0);
-                    pt2 = new XYZ(0, plate.Size.Width, 0);
-                    pt3 = new XYZ(-plate.Size.Length, plate.Size.Width, 0);
-                    pt4 = new XYZ(-plate.Size.Length, 0, 0);
-                    break;
-
-                case 3:
-                    pt1 = new XYZ(0, 0, 0);
-                    pt2 = new XYZ(0, -plate.Size.Width, 0);
-                    pt3 = new XYZ(-plate.Size.Length, -plate.Size.Width, 0);
-                    pt4 = new XYZ(-plate.Size.Length, 0, 0);
-                    break;
-
-                case 4:
-                    pt1 = new XYZ(0, 0, 0);
-                    pt2 = new XYZ(0, -plate.Size.Width, 0);
-                    pt3 = new XYZ(plate.Size.Length, -plate.Size.Width, 0);
-                    pt4 = new XYZ(plate.Size.Length, 0, 0);
-                    break;
-
-                default:
-                    return;
-            }
-
-            AddLine(pt1, pt2, plateLayer);
-            AddLine(pt2, pt3, plateLayer);
-            AddLine(pt3, pt4, plateLayer);
-            AddLine(pt4, pt1, plateLayer);
-
-            var m1 = new XYZ(pt1.X + plate.EdgeSpacing.Left, pt1.Y + plate.EdgeSpacing.Bottom, 0);
-            var m2 = new XYZ(m1.X, pt2.Y - plate.EdgeSpacing.Top, 0);
-            var m3 = new XYZ(pt3.X - plate.EdgeSpacing.Right, m2.Y, 0);
-            var m4 = new XYZ(m3.X, m1.Y, 0);
-
-            AddLine(m1, m2, plateLayer);
-            AddLine(m2, m3, plateLayer);
-            AddLine(m3, m4, plateLayer);
-            AddLine(m4, m1, plateLayer);
-        }
-
-        private void AddProgram(Program program)
-        {
-            mode = program.Mode;
-
-            for (var i = 0; i < program.Length; ++i)
-            {
-                var code = program[i];
-
-                switch (code.Type)
-                {
-                    case CodeType.ArcMove:
-                        var arc = (ArcMove)code;
-                        AddArcMove(arc);
-                        break;
-
-                    case CodeType.LinearMove:
-                        var line = (LinearMove)code;
-                        AddLinearMove(line);
-                        break;
-
-                    case CodeType.RapidMove:
-                        var rapid = (RapidMove)code;
-                        AddRapidMove(rapid);
-                        break;
-
-                    case CodeType.SubProgramCall:
-                        var tmpmode = mode;
-                        var subpgm = (CNC.SubProgramCall)code;
-                        AddProgram(subpgm.Program);
-                        mode = tmpmode;
-                        break;
-                }
-            }
-        }
-
-        private void AddLinearMove(LinearMove line)
-        {
-            var pt = line.EndPoint.ToAcadXYZ();
-
-            if (mode == Mode.Incremental)
-                pt = new XYZ(pt.X + curpos.X, pt.Y + curpos.Y, 0);
-
-            AddLine(curpos, pt, cutLayer);
-            curpos = pt;
-        }
-
-        private void AddRapidMove(RapidMove rapid)
-        {
-            var pt = rapid.EndPoint.ToAcadXYZ();
-
-            if (mode == Mode.Incremental)
-                pt = new XYZ(pt.X + curpos.X, pt.Y + curpos.Y, 0);
-
-            AddLine(curpos, pt, rapidLayer);
-            curpos = pt;
-        }
-
-        private void AddArcMove(ArcMove arc)
-        {
-            var center = arc.CenterPoint.ToAcadXYZ();
-            var endpt = arc.EndPoint.ToAcadXYZ();
-
-            if (mode == Mode.Incremental)
-            {
-                endpt = new XYZ(endpt.X + curpos.X, endpt.Y + curpos.Y, 0);
-                center = new XYZ(center.X + curpos.X, center.Y + curpos.Y, 0);
-            }
-
-            var startAngle = System.Math.Atan2(
-                curpos.Y - center.Y,
-                curpos.X - center.X);
-
-            var endAngle = System.Math.Atan2(
-                endpt.Y - center.Y,
-                endpt.X - center.X);
-
-            if (arc.Rotation == OpenNest.RotationType.CW)
-                Generic.Swap(ref startAngle, ref endAngle);
-
-            var dx = endpt.X - center.X;
-            var dy = endpt.Y - center.Y;
-
-            var radius = System.Math.Sqrt(dx * dx + dy * dy);
-
-            if (startAngle.IsEqualTo(endAngle))
-            {
-                var circle = new AcadCircle();
-                circle.Center = center;
-                circle.Radius = radius;
-                circle.Layer = cutLayer;
-                doc.Entities.Add(circle);
-            }
-            else
-            {
-                var arc2 = new AcadArc();
-                arc2.Center = center;
-                arc2.Radius = radius;
-                arc2.StartAngle = startAngle;
-                arc2.EndAngle = endAngle;
-                arc2.Layer = cutLayer;
-                doc.Entities.Add(arc2);
-            }
-
-            curpos = endpt;
-        }
-    }
-}

OpenNest.IO/DxfImporter.cs

@@ -1,155 +0,0 @@
-using ACadSharp;
-using ACadSharp.IO;
-using OpenNest.Geometry;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-
-namespace OpenNest.IO
-{
-    public class DxfImporter
-    {
-        public int SplinePrecision { get; set; }
-
-        public DxfImporter()
-        {
-        }
-
-        private List<Entity> GetGeometry(CadDocument doc)
-        {
-            var entities = new List<Entity>();
-            var lines = new List<Line>();
-            var arcs = new List<Arc>();
-
-            foreach (var entity in doc.Entities)
-            {
-                // Skip bend/etch entities — bends are converted to Bend objects
-                // separately via bend detection, and etch marks are generated from
-                // bends during DXF export. Neither should be treated as cut geometry.
-                if (IsNonCutLayer(entity.Layer?.Name))
-                    continue;
-
-                switch (entity)
-                {
-                    case ACadSharp.Entities.Line line:
-                        lines.Add(line.ToOpenNest());
-                        break;
-
-                    case ACadSharp.Entities.Arc arc:
-                        arcs.Add(arc.ToOpenNest());
-                        break;
-
-                    case ACadSharp.Entities.Circle circle:
-                        entities.Add(circle.ToOpenNest());
-                        break;
-
-                    case ACadSharp.Entities.Spline spline:
-                        foreach (var e in spline.ToOpenNest(SplinePrecision))
-                        {
-                            if (e is Line l) lines.Add(l);
-                            else if (e is Arc a) arcs.Add(a);
-                        }
-                        break;
-
-                    case ACadSharp.Entities.LwPolyline lwPolyline:
-                        lines.AddRange(lwPolyline.ToOpenNest());
-                        break;
-
-                    case ACadSharp.Entities.Polyline polyline:
-                        lines.AddRange(polyline.ToOpenNest());
-                        break;
-
-                    case ACadSharp.Entities.Ellipse ellipse:
-                        foreach (var e in ellipse.ToOpenNest())
-                        {
-                            if (e is Line l) lines.Add(l);
-                            else if (e is Arc a) arcs.Add(a);
-                        }
-                        break;
-                }
-            }
-
-            GeometryOptimizer.Optimize(lines);
-            GeometryOptimizer.Optimize(arcs);
-
-            entities.AddRange(lines);
-            entities.AddRange(arcs);
-
-            return entities;
-        }
-
-        /// <summary>
-        /// Imports a DXF file, returning both converted entities and the raw CadDocument
-        /// for bend detection. The CadDocument is NOT disposed — caller can use it for
-        /// additional analysis (e.g., MText extraction for bend notes).
-        /// </summary>
-        public DxfImportResult Import(string path)
-        {
-            using var reader = new DxfReader(path);
-            var doc = reader.Read();
-            var entities = GetGeometry(doc);
-
-            return new DxfImportResult
-            {
-                Entities = entities,
-                Document = doc
-            };
-        }
-
-        public bool GetGeometry(Stream stream, out List<Entity> geometry)
-        {
-            var success = false;
-
-            try
-            {
-                using (var reader = new DxfReader(stream))
-                {
-                    var doc = reader.Read();
-                    geometry = GetGeometry(doc);
-                    success = true;
-                }
-            }
-            catch (Exception ex)
-            {
-                Debug.WriteLine(ex.Message);
-                geometry = new List<Entity>();
-            }
-            finally
-            {
-                if (stream != null)
-                    stream.Close();
-            }
-
-            return success;
-        }
-
-        public bool GetGeometry(string path, out List<Entity> geometry)
-        {
-            var success = false;
-
-            try
-            {
-                using (var reader = new DxfReader(path))
-                {
-                    var doc = reader.Read();
-                    geometry = GetGeometry(doc);
-                    success = true;
-                }
-            }
-            catch (Exception ex)
-            {
-                Debug.WriteLine(ex.Message);
-                geometry = new List<Entity>();
-            }
-
-            return success;
-        }
-
-        private static bool IsNonCutLayer(string layerName)
-        {
-            return string.Equals(layerName, "BEND", System.StringComparison.OrdinalIgnoreCase)
-                || string.Equals(layerName, "ETCH", System.StringComparison.OrdinalIgnoreCase);
-        }
-    }
-}

OpenNest.IO/EntitySerializer.cs

@@ -0,0 +1,139 @@
+using OpenNest.Geometry;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using static OpenNest.IO.NestFormat;
+
+namespace OpenNest.IO
+{
+    public static class EntitySerializer
+    {
+        public static EntitySetDto ToDto(List<Entity> entities, HashSet<Guid> suppressed)
+        {
+            return new EntitySetDto
+            {
+                Entities = entities.Select(ToEntityDto).ToList(),
+                Suppressed = suppressed.Select(id => id.ToString()).ToList()
+            };
+        }
+
+        public static (List<Entity> entities, HashSet<Guid> suppressed) FromDto(EntitySetDto dto)
+        {
+            var entities = dto.Entities.Select(FromEntityDto).ToList();
+            var suppressed = new HashSet<Guid>(dto.Suppressed.Select(Guid.Parse));
+            return (entities, suppressed);
+        }
+
+        private static EntityDto ToEntityDto(Entity entity)
+        {
+            switch (entity.Type)
+            {
+                case EntityType.Line:
+                    var line = (Line)entity;
+                    return new EntityDto
+                    {
+                        Id = entity.Id.ToString(),
+                        Type = "line",
+                        Layer = entity.Layer?.Name ?? "",
+                        LineType = entity.LineTypeName ?? "",
+                        X1 = line.StartPoint.X,
+                        Y1 = line.StartPoint.Y,
+                        X2 = line.EndPoint.X,
+                        Y2 = line.EndPoint.Y
+                    };
+
+                case EntityType.Arc:
+                    var arc = (Arc)entity;
+                    return new EntityDto
+                    {
+                        Id = entity.Id.ToString(),
+                        Type = "arc",
+                        Layer = entity.Layer?.Name ?? "",
+                        LineType = entity.LineTypeName ?? "",
+                        CX = arc.Center.X,
+                        CY = arc.Center.Y,
+                        R = arc.Radius,
+                        StartAngle = arc.StartAngle,
+                        EndAngle = arc.EndAngle,
+                        Reversed = arc.IsReversed
+                    };
+
+                case EntityType.Circle:
+                    var circle = (Circle)entity;
+                    return new EntityDto
+                    {
+                        Id = entity.Id.ToString(),
+                        Type = "circle",
+                        Layer = entity.Layer?.Name ?? "",
+                        LineType = entity.LineTypeName ?? "",
+                        CX = circle.Center.X,
+                        CY = circle.Center.Y,
+                        R = circle.Radius,
+                        Rotation = circle.Rotation == RotationType.CW ? "CW" : "CCW"
+                    };
+
+                default:
+                    throw new NotSupportedException($"Entity type {entity.Type} is not supported for serialization.");
+            }
+        }
+
+        private static Entity FromEntityDto(EntityDto dto)
+        {
+            Entity entity;
+
+            switch (dto.Type)
+            {
+                case "line":
+                    entity = new Line(
+                        new Vector(dto.X1, dto.Y1),
+                        new Vector(dto.X2, dto.Y2));
+                    break;
+
+                case "arc":
+                    entity = new Arc(
+                        new Vector(dto.CX, dto.CY),
+                        dto.R,
+                        dto.StartAngle,
+                        dto.EndAngle,
+                        dto.Reversed);
+                    break;
+
+                case "circle":
+                    var circle = new Circle(new Vector(dto.CX, dto.CY), dto.R);
+                    circle.Rotation = dto.Rotation == "CW" ? RotationType.CW : RotationType.CCW;
+                    entity = circle;
+                    break;
+
+                default:
+                    throw new NotSupportedException($"Entity type '{dto.Type}' is not supported for deserialization.");
+            }
+
+            entity.Id = Guid.Parse(dto.Id);
+            entity.Layer = ResolveLayer(dto.Layer);
+            entity.LineTypeName = dto.LineType;
+
+            return entity;
+        }
+
+        private static Layer ResolveLayer(string name)
+        {
+            if (string.IsNullOrEmpty(name) || name == "0")
+                return Layer.Default;
+
+            if (string.Equals(name, SpecialLayers.Cut.Name, StringComparison.OrdinalIgnoreCase))
+                return SpecialLayers.Cut;
+            if (string.Equals(name, SpecialLayers.Rapid.Name, StringComparison.OrdinalIgnoreCase))
+                return SpecialLayers.Rapid;
+            if (string.Equals(name, SpecialLayers.Display.Name, StringComparison.OrdinalIgnoreCase))
+                return SpecialLayers.Display;
+            if (string.Equals(name, SpecialLayers.Leadin.Name, StringComparison.OrdinalIgnoreCase))
+                return SpecialLayers.Leadin;
+            if (string.Equals(name, SpecialLayers.Leadout.Name, StringComparison.OrdinalIgnoreCase))
+                return SpecialLayers.Leadout;
+            if (string.Equals(name, SpecialLayers.Scribe.Name, StringComparison.OrdinalIgnoreCase))
+                return SpecialLayers.Scribe;
+
+            return new Layer(name);
+        }
+    }
+}

OpenNest.IO/Extensions.cs

@@ -57,7 +57,7 @@ namespace OpenNest.IO
             return result;
         }
 
-        public static List<Geometry.Entity> ToOpenNest(this Spline spline, int precision)
+        public static List<Geometry.Entity> ToOpenNest(this Spline spline)
         {
             var layer = spline.Layer.ToOpenNest();
             var color = spline.ResolveColor();
@@ -67,7 +67,7 @@ namespace OpenNest.IO
             List<XYZ> curvePoints;
             try
             {
-                curvePoints = spline.PolygonalVertexes(precision > 0 ? precision : 200);
+                curvePoints = spline.PolygonalVertexes(200);
             }
             catch (Exception ex)
             {
@@ -181,13 +181,22 @@ namespace OpenNest.IO
         {
             var center = new Vector(ellipse.Center.X, ellipse.Center.Y);
             var majorAxis = new Vector(ellipse.MajorAxisEndPoint.X, ellipse.MajorAxisEndPoint.Y);
-            var semiMajor = System.Math.Sqrt(majorAxis.X * majorAxis.X + majorAxis.Y * majorAxis.Y);
-            var semiMinor = semiMajor * ellipse.RadiusRatio;
-            var rotation = System.Math.Atan2(majorAxis.Y, majorAxis.X);
 
             var startParam = ellipse.StartParameter;
             var endParam = ellipse.EndParameter;
 
+            if (ellipse.Normal.Z < 0)
+            {
+                var newStart = OpenNest.Math.Angle.TwoPI - endParam;
+                var newEnd = OpenNest.Math.Angle.TwoPI - startParam;
+                startParam = newStart;
+                endParam = newEnd;
+            }
+
+            var semiMajor = System.Math.Sqrt(majorAxis.X * majorAxis.X + majorAxis.Y * majorAxis.Y);
+            var semiMinor = semiMajor * ellipse.RadiusRatio;
+            var rotation = System.Math.Atan2(majorAxis.Y, majorAxis.X);
+
             var layer = ellipse.Layer.ToOpenNest();
             var color = ellipse.ResolveColor();
             var lineTypeName = ellipse.ResolveLineTypeName();

OpenNest.IO/NestFormat.cs

@@ -162,6 +162,35 @@ namespace OpenNest.IO
             public double Cost { get; init; }
         }
 
+        public record EntitySetDto
+        {
+            public List<EntityDto> Entities { get; init; } = new();
+            public List<string> Suppressed { get; init; } = new();
+        }
+
+        public record EntityDto
+        {
+            public string Id { get; init; } = "";
+            public string Type { get; init; } = "";
+            public string Layer { get; init; } = "";
+            public string LineType { get; init; } = "";
+
+            // Line
+            public double X1 { get; init; }
+            public double Y1 { get; init; }
+            public double X2 { get; init; }
+            public double Y2 { get; init; }
+
+            // Arc / Circle
+            public double CX { get; init; }
+            public double CY { get; init; }
+            public double R { get; init; }
+            public double StartAngle { get; init; }
+            public double EndAngle { get; init; }
+            public bool Reversed { get; init; }
+            public string Rotation { get; init; } = "";
+        }
+
         public record BestFitSetDto
         {
             public double PlateWidth { get; init; }

OpenNest.IO/NestReader.cs

@@ -36,7 +36,8 @@ namespace OpenNest.IO
             var dto = JsonSerializer.Deserialize<NestDto>(nestJson, JsonOptions);
 
             var programs = ReadPrograms(dto.Drawings.Count);
-            var drawingMap = BuildDrawings(dto, programs);
+            var entitySets = ReadEntitySets(dto.Drawings.Count);
+            var drawingMap = BuildDrawings(dto, programs, entitySets);
             ReadBestFits(drawingMap);
             var nest = BuildNest(dto, drawingMap);
 
@@ -70,11 +71,87 @@ namespace OpenNest.IO
 
                 var reader = new ProgramReader(memStream);
                 programs[i] = reader.Read();
+
+                // Read sub-programs if present
+                var subsEntry = zipArchive.GetEntry($"programs/program-{i}-subs");
+                if (subsEntry != null)
+                {
+                    using var subsStream = subsEntry.Open();
+                    ReadSubPrograms(programs[i], subsStream);
+                }
             }
             return programs;
         }
 
-        private Dictionary<int, Drawing> BuildDrawings(NestDto dto, Dictionary<int, Program> programs)
+        private static void ReadSubPrograms(Program parent, Stream stream)
+        {
+            using var reader = new StreamReader(stream);
+            var currentId = -1;
+            var lines = new List<string>();
+
+            string line;
+            while ((line = reader.ReadLine()) != null)
+            {
+                var trimmed = line.Trim();
+
+                if (trimmed.StartsWith(":") && int.TryParse(trimmed.Substring(1), out var id))
+                {
+                    // Flush previous sub-program
+                    if (currentId >= 0 && lines.Count > 0)
+                        parent.SubPrograms[currentId] = ParseSubProgram(lines);
+
+                    currentId = id;
+                    lines.Clear();
+                }
+                else if (trimmed == "M99")
+                {
+                    if (currentId >= 0 && lines.Count > 0)
+                        parent.SubPrograms[currentId] = ParseSubProgram(lines);
+
+                    currentId = -1;
+                    lines.Clear();
+                }
+                else
+                {
+                    lines.Add(trimmed);
+                }
+            }
+
+            // Wire up SubProgramCall.Program references
+            foreach (var code in parent.Codes)
+            {
+                if (code is SubProgramCall call && parent.SubPrograms.TryGetValue(call.Id, out var sub))
+                    call.Program = sub;
+            }
+        }
+
+        private static Program ParseSubProgram(List<string> lines)
+        {
+            var text = string.Join("\n", lines);
+            var memStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(text));
+            var reader = new ProgramReader(memStream);
+            return reader.Read();
+        }
+
+        private Dictionary<int, (List<Entity> entities, HashSet<Guid> suppressed)> ReadEntitySets(int count)
+        {
+            var result = new Dictionary<int, (List<Entity>, HashSet<Guid>)>();
+            for (var i = 1; i <= count; i++)
+            {
+                var entry = zipArchive.GetEntry($"entities/entities-{i}");
+                if (entry == null) continue;
+
+                using var entryStream = entry.Open();
+                using var reader = new StreamReader(entryStream);
+                var json = reader.ReadToEnd();
+                var dto = JsonSerializer.Deserialize<EntitySetDto>(json, JsonOptions);
+                result[i] = EntitySerializer.FromDto(dto);
+            }
+            return result;
+        }
+
+        private Dictionary<int, Drawing> BuildDrawings(NestDto dto, Dictionary<int, Program> programs,
+            Dictionary<int, (List<Entity> entities, HashSet<Guid> suppressed)> entitySets)
         {
             var map = new Dictionary<int, Drawing>();
             foreach (var d in dto.Drawings)
@@ -112,6 +189,12 @@ namespace OpenNest.IO
                 if (programs.TryGetValue(d.Id, out var pgm))
                     drawing.Program = pgm;
 
+                if (entitySets.TryGetValue(d.Id, out var entitySet))
+                {
+                    drawing.SourceEntities = entitySet.entities;
+                    drawing.SuppressedEntityIds = entitySet.suppressed;
+                }
+
                 map[d.Id] = drawing;
             }
             return map;

OpenNest.IO/NestWriter.cs

@@ -41,6 +41,7 @@ namespace OpenNest.IO
 
             WriteNestJson(zipArchive);
             WritePrograms(zipArchive);
+            WriteEntities(zipArchive);
             WriteBestFits(zipArchive);
 
             return true;
@@ -307,8 +308,50 @@ namespace OpenNest.IO
                 WriteDrawing(stream, kvp.Value);
 
                 var entry = zipArchive.CreateEntry(name);
-                using var entryStream = entry.Open();
-                stream.CopyTo(entryStream);
+                using (var entryStream = entry.Open())
+                {
+                    stream.CopyTo(entryStream);
+                }
+
+                // Write sub-programs if present
+                if (kvp.Value.Program.SubPrograms.Count > 0)
+                    WriteSubPrograms(zipArchive, kvp.Key, kvp.Value.Program.SubPrograms);
+            }
+        }
+
+        private void WriteSubPrograms(ZipArchive zipArchive, int drawingId, Dictionary<int, Program> subPrograms)
+        {
+            var entry = zipArchive.CreateEntry($"programs/program-{drawingId}-subs");
+            using var entryStream = entry.Open();
+            using var writer = new StreamWriter(entryStream, Encoding.UTF8);
+
+            foreach (var kvp in subPrograms.OrderBy(k => k.Key))
+            {
+                writer.WriteLine($":{kvp.Key}");
+                writer.WriteLine(kvp.Value.Mode == Mode.Absolute ? "G90" : "G91");
+
+                foreach (var code in kvp.Value.Codes)
+                    writer.WriteLine(GetCodeString(code));
+
+                writer.WriteLine("M99");
+            }
+        }
+
+        private void WriteEntities(ZipArchive zipArchive)
+        {
+            foreach (var kvp in drawingDict.OrderBy(k => k.Key))
+            {
+                var drawing = kvp.Value;
+                if (drawing.SourceEntities == null || drawing.SourceEntities.Count == 0)
+                    continue;
+
+                var dto = EntitySerializer.ToDto(drawing.SourceEntities, drawing.SuppressedEntityIds);
+                var json = JsonSerializer.Serialize(dto, JsonOptions);
+
+                var entry = zipArchive.CreateEntry($"entities/entities-{kvp.Key}");
+                using var stream = entry.Open();
+                using var writer = new StreamWriter(stream, Encoding.UTF8);
+                writer.Write(json);
             }
         }
 
@@ -429,7 +472,9 @@ namespace OpenNest.IO
                 case CodeType.SubProgramCall:
                     {
                         var subProgramCall = (SubProgramCall)code;
-                        break;
+                        var x = System.Math.Round(subProgramCall.Offset.X, OutputPrecision).ToString(CoordinateFormat);
+                        var y = System.Math.Round(subProgramCall.Offset.Y, OutputPrecision).ToString(CoordinateFormat);
+                        return $"G65P{subProgramCall.Id}X{x}Y{y}";
                     }
             }
 

OpenNest.IO/OpenNest.IO.csproj

@@ -4,6 +4,9 @@
     <RootNamespace>OpenNest.IO</RootNamespace>
     <AssemblyName>OpenNest.IO</AssemblyName>
   </PropertyGroup>
+  <ItemGroup>
+    <InternalsVisibleTo Include="OpenNest.Tests" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />
     <ProjectReference Include="..\OpenNest.Engine\OpenNest.Engine.csproj" />

OpenNest.IO/ProgramReader.cs

@@ -374,6 +374,8 @@ namespace OpenNest.IO
         {
             var p = 0;
             var r = 0.0;
+            var x = 0.0;
+            var y = 0.0;
 
             while (section == CodeSection.SubProgram)
             {
@@ -395,13 +397,26 @@ namespace OpenNest.IO
                         r = double.Parse(code.Value);
                         break;
 
+                    case 'X':
+                        x = double.Parse(code.Value);
+                        break;
+
+                    case 'Y':
+                        y = double.Parse(code.Value);
+                        break;
+
                     default:
                         section = CodeSection.Unknown;
                         break;
                 }
             }
 
-            program.Codes.Add(new SubProgramCall() { Id = p, Rotation = r });
+            program.Codes.Add(new SubProgramCall
+            {
+                Id = p,
+                Rotation = r,
+                Offset = new Geometry.Vector(x, y)
+            });
         }
 
         private Code GetNextCode()

OpenNest.Mcp/Tools/InputTools.cs

@@ -1,6 +1,4 @@
 using ModelContextProtocol.Server;
-using OpenNest.Converters;
-using OpenNest.Geometry;
 using OpenNest.IO;
 using OpenNest.Shapes;
 using System.ComponentModel;
@@ -96,27 +94,18 @@ namespace OpenNest.Mcp.Tools
             if (!File.Exists(path))
                 return $"Error: file not found: {path}";
 
-            var importer = new DxfImporter();
+            try
+            {
+                var drawing = CadImporter.ImportDrawing(path, new CadImportOptions { Name = name });
+                _session.Drawings.Add(drawing);
 
-            if (!importer.GetGeometry(path, out var geometry))
-                return "Error: failed to read DXF file";
-
-            if (geometry.Count == 0)
-                return "Error: no geometry found in DXF file";
-
-            var normalized = ShapeProfile.NormalizeEntities(geometry);
-            var pgm = ConvertGeometry.ToProgram(normalized);
-
-            if (pgm == null)
-                return "Error: failed to convert geometry to program";
-
-            var drawingName = name ?? Path.GetFileNameWithoutExtension(path);
-            var drawing = new Drawing(drawingName, pgm);
-            drawing.Color = Drawing.GetNextColor();
-            _session.Drawings.Add(drawing);
-
-            var bbox = pgm.BoundingBox();
-            return $"Imported drawing '{drawingName}': bbox={bbox.Width:F2} x {bbox.Length:F2}";
+                var bbox = drawing.Program.BoundingBox();
+                return $"Imported drawing '{drawing.Name}': bbox={bbox.Width:F2} x {bbox.Length:F2}";
+            }
+            catch (System.Exception ex)
+            {
+                return $"Error: failed to import '{path}': {ex.Message}";
+            }
         }
 
         [McpServerTool(Name = "create_drawing")]

OpenNest.Posts.Cincinnati/CincinnatiPartSubprogramWriter.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
 using OpenNest.CNC;
 using OpenNest.Geometry;
 
@@ -15,11 +16,16 @@ public sealed class CincinnatiPartSubprogramWriter
 {
     private readonly CincinnatiPostConfig _config;
     private readonly CincinnatiFeatureWriter _featureWriter;
+    private readonly CoordinateFormatter _fmt;
+    private readonly Dictionary<int, int> _holeSubprograms;
 
-    public CincinnatiPartSubprogramWriter(CincinnatiPostConfig config)
+    public CincinnatiPartSubprogramWriter(CincinnatiPostConfig config,
+        Dictionary<int, int> holeSubprograms = null)
     {
         _config = config;
         _featureWriter = new CincinnatiFeatureWriter(config);
+        _fmt = new CoordinateFormatter(config.PostedAccuracy);
+        _holeSubprograms = holeSubprograms;
     }
 
     /// <summary>
@@ -43,6 +49,15 @@ public sealed class CincinnatiPartSubprogramWriter
         for (var i = 0; i < ordered.Count; i++)
         {
             var (codes, isEtch) = ordered[i];
+            var isLastFeature = i == ordered.Count - 1;
+
+            // SubProgramCall features are emitted as M98 hole calls
+            if (codes.Count == 1 && codes[0] is SubProgramCall holeCall)
+            {
+                WriteHoleSubprogramCall(w, holeCall, i, isLastFeature);
+                continue;
+            }
+
             var featureNumber = i == 0
                 ? _config.FeatureLineNumberStart
                 : 1000 + i + 1;
@@ -54,7 +69,7 @@ public sealed class CincinnatiPartSubprogramWriter
                 FeatureNumber = featureNumber,
                 PartName = drawingName,
                 IsFirstFeatureOfPart = false,
-                IsLastFeatureOnSheet = i == ordered.Count - 1,
+                IsLastFeatureOnSheet = isLastFeature,
                 IsSafetyHeadraise = false,
                 IsExteriorFeature = false,
                 IsEtch = isEtch,
@@ -69,6 +84,30 @@ public sealed class CincinnatiPartSubprogramWriter
         w.WriteLine($"M99 (END OF {drawingName})");
     }
 
+    private void WriteHoleSubprogramCall(TextWriter w, SubProgramCall call,
+        int featureIndex, bool isLastFeature)
+    {
+        var postSubNum = _holeSubprograms != null && _holeSubprograms.TryGetValue(call.Id, out var num)
+            ? num : call.Id;
+
+        var featureNumber = featureIndex == 0
+            ? _config.FeatureLineNumberStart
+            : 1000 + featureIndex + 1;
+
+        var sb = new StringBuilder();
+        if (_config.UseLineNumbers)
+            sb.Append($"N{featureNumber} ");
+        sb.Append($"G52 X{_fmt.FormatCoord(call.Offset.X)} Y{_fmt.FormatCoord(call.Offset.Y)}");
+        w.WriteLine(sb.ToString());
+
+        w.WriteLine($"M98 P{postSubNum}");
+
+        w.WriteLine("G52 X0 Y0");
+
+        if (!isLastFeature)
+            w.WriteLine("M47");
+    }
+
     /// <summary>
     /// If the program has no leading rapid, inserts a synthetic rapid at the
     /// last motion endpoint (the contour return point). This ensures the feature
@@ -136,4 +175,61 @@ public sealed class CincinnatiPartSubprogramWriter
 
         return (mapping, entries);
     }
+
+    /// <summary>
+    /// Scans all parts across all plates and builds a nest-level registry of unique
+    /// hole sub-programs. Deduplicates by comparing sub-program code content.
+    /// </summary>
+    internal static (Dictionary<int, int> modelToPostMapping, List<(int subNum, Program program)> entries)
+        BuildHoleRegistry(IEnumerable<Plate> plates, int startNumber)
+    {
+        var mapping = new Dictionary<int, int>();
+        var entries = new List<(int, Program)>();
+        var contentIndex = new Dictionary<string, int>();
+        var nextSubNum = startNumber;
+
+        foreach (var plate in plates)
+        {
+            foreach (var part in plate.Parts)
+            {
+                if (part.BaseDrawing.IsCutOff) continue;
+                foreach (var code in part.Program.Codes)
+                {
+                    if (code is not SubProgramCall call) continue;
+                    if (mapping.ContainsKey(call.Id)) continue;
+
+                    var canonical = ProgramToCanonical(call.Program);
+                    if (contentIndex.TryGetValue(canonical, out var existingNum))
+                    {
+                        mapping[call.Id] = existingNum;
+                    }
+                    else
+                    {
+                        var subNum = nextSubNum++;
+                        mapping[call.Id] = subNum;
+                        contentIndex[canonical] = subNum;
+                        entries.Add((subNum, call.Program));
+                    }
+                }
+            }
+        }
+
+        return (mapping, entries);
+    }
+
+    private static string ProgramToCanonical(Program pgm)
+    {
+        var sb = new StringBuilder();
+        sb.Append(pgm.Mode == Mode.Absolute ? "A" : "I");
+        foreach (var code in pgm.Codes)
+        {
+            if (code is LinearMove lm)
+                sb.Append($"L{lm.EndPoint.X:F6},{lm.EndPoint.Y:F6},{(int)lm.Layer}");
+            else if (code is ArcMove am)
+                sb.Append($"A{am.EndPoint.X:F6},{am.EndPoint.Y:F6},{am.CenterPoint.X:F6},{am.CenterPoint.Y:F6},{(int)am.Rotation},{(int)am.Layer}");
+            else if (code is RapidMove rm)
+                sb.Append($"R{rm.EndPoint.X:F6},{rm.EndPoint.Y:F6}");
+        }
+        return sb.ToString();
+    }
 }

OpenNest.Posts.Cincinnati/CincinnatiPostConfig.cs

@@ -1,5 +1,7 @@
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
 
 namespace OpenNest.Posts.Cincinnati
 {
@@ -277,6 +279,24 @@ namespace OpenNest.Posts.Cincinnati
         [DisplayName("Etch Libraries")]
         [Description("Gas-to-library mapping for etch operations.")]
         public List<EtchLibraryEntry> EtchLibraries { get; set; } = new();
+
+        [Category("B. Libraries")]
+        [DisplayName("Selected Library")]
+        [Description("Overrides Material/Thickness/Gas auto-resolution. Pick an existing entry from Material Libraries, or leave blank to auto-resolve.")]
+        [TypeConverter(typeof(MaterialLibraryNameConverter))]
+        public string SelectedLibrary { get; set; } = "";
+
+        public string FindBestLibrary(string materialName, double thickness)
+        {
+            if (MaterialLibraries == null || string.IsNullOrEmpty(materialName))
+                return "";
+
+            return MaterialLibraries
+                .Where(e => string.Equals(e.Material, materialName, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(e => System.Math.Abs(e.Thickness - thickness))
+                .Select(e => e.Library)
+                .FirstOrDefault() ?? "";
+        }
     }
 
     public class MaterialLibraryEntry

OpenNest.Posts.Cincinnati/CincinnatiPostProcessor.cs

@@ -9,7 +9,7 @@ using OpenNest.CNC;
 
 namespace OpenNest.Posts.Cincinnati
 {
-    public sealed class CincinnatiPostProcessor : IConfigurablePostProcessor
+    public sealed class CincinnatiPostProcessor : IConfigurablePostProcessor, IPostProcessorNestAware, IMaterialProvidingPostProcessor
     {
         private static readonly JsonSerializerOptions JsonOptions = new()
         {
@@ -25,6 +25,23 @@ namespace OpenNest.Posts.Cincinnati
 
         object IConfigurablePostProcessor.Config => Config;
 
+        public IEnumerable<string> GetMaterialNames()
+        {
+            if (Config?.MaterialLibraries == null)
+                return System.Array.Empty<string>();
+
+            return Config.MaterialLibraries
+                .Select(e => e.Material)
+                .Where(s => !string.IsNullOrWhiteSpace(s));
+        }
+
+        public void PrepareForNest(Nest nest)
+        {
+            var materialName = nest?.Material?.Name ?? "";
+            var thickness = nest?.Thickness ?? 0.0;
+            Config.SelectedLibrary = Config.FindBestLibrary(materialName, thickness);
+        }
+
         public CincinnatiPostProcessor()
         {
             var configPath = GetConfigPath();
@@ -89,9 +106,15 @@ namespace OpenNest.Posts.Cincinnati
             if (Config.UsePartSubprograms)
                 (partSubprograms, subprogramEntries) = CincinnatiPartSubprogramWriter.BuildRegistry(plates, Config.PartSubprogramStart);
 
+            // 5b. Build hole sub-program registry (SubProgramCalls across all parts)
+            var holeStartNumber = Config.PartSubprogramStart
+                + (subprogramEntries?.Count ?? 0);
+            var (holeMapping, holeEntries) = CincinnatiPartSubprogramWriter.BuildHoleRegistry(plates, holeStartNumber);
+
             // 6. Create writers
             var preamble = new CincinnatiPreambleWriter(Config);
-            var sheetWriter = new CincinnatiSheetWriter(Config, vars);
+            var sheetWriter = new CincinnatiSheetWriter(Config, vars,
+                holeMapping.Count > 0 ? holeMapping : null);
 
             // 7. Build material description from nest
             var material = nest.Material;
@@ -122,7 +145,8 @@ namespace OpenNest.Posts.Cincinnati
             // Part sub-programs (if enabled)
             if (subprogramEntries != null)
             {
-                var partSubWriter = new CincinnatiPartSubprogramWriter(Config);
+                var partSubWriter = new CincinnatiPartSubprogramWriter(Config,
+                    holeMapping.Count > 0 ? holeMapping : null);
                 var sheetDiagonal = firstPlate != null
                     ? System.Math.Sqrt(firstPlate.Size.Width * firstPlate.Size.Width
                         + firstPlate.Size.Length * firstPlate.Size.Length)
@@ -135,6 +159,23 @@ namespace OpenNest.Posts.Cincinnati
                 }
             }
 
+            // Hole sub-programs (SubProgramCall definitions)
+            if (holeEntries.Count > 0)
+            {
+                var holeSubWriter = new CincinnatiPartSubprogramWriter(Config);
+                var sheetDiagonal = firstPlate != null
+                    ? System.Math.Sqrt(firstPlate.Size.Width * firstPlate.Size.Width
+                        + firstPlate.Size.Length * firstPlate.Size.Length)
+                    : 100.0;
+
+                foreach (var (subNum, pgm) in holeEntries)
+                {
+                    CincinnatiPartSubprogramWriter.EnsureLeadingRapid(pgm);
+                    holeSubWriter.Write(writer, pgm, "HOLE", subNum,
+                        initialCutLibrary, etchLibrary, sheetDiagonal);
+                }
+            }
+
             writer.Flush();
         }
 

OpenNest.Posts.Cincinnati/CincinnatiSheetWriter.cs

@@ -17,13 +17,16 @@ public sealed class CincinnatiSheetWriter
     private readonly ProgramVariableManager _vars;
     private readonly CoordinateFormatter _fmt;
     private readonly CincinnatiFeatureWriter _featureWriter;
+    private readonly Dictionary<int, int> _holeSubprograms;
 
-    public CincinnatiSheetWriter(CincinnatiPostConfig config, ProgramVariableManager vars)
+    public CincinnatiSheetWriter(CincinnatiPostConfig config, ProgramVariableManager vars,
+        Dictionary<int, int> holeSubprograms = null)
     {
         _config = config;
         _vars = vars;
         _fmt = new CoordinateFormatter(config.PostedAccuracy);
         _featureWriter = new CincinnatiFeatureWriter(config);
+        _holeSubprograms = holeSubprograms;
     }
 
     /// <summary>
@@ -132,11 +135,21 @@ public sealed class CincinnatiSheetWriter
                 for (var f = 0; f < features.Count; f++)
                 {
                     var (codes, isEtch) = features[f];
+                    var isLastFeature = isLastPart && f == features.Count - 1;
+
+                    // SubProgramCall features are emitted as M98 hole calls
+                    if (codes.Count == 1 && codes[0] is SubProgramCall holeCall)
+                    {
+                        WriteHoleSubprogramCall(w, holeCall, featureIndex, isLastFeature);
+                        featureIndex++;
+                        lastPartName = partName;
+                        continue;
+                    }
+
                     var featureNumber = featureIndex == 0
                         ? _config.FeatureLineNumberStart
                         : 1000 + featureIndex + 1;
 
-                    var isLastFeature = isLastPart && f == features.Count - 1;
                     var cutDistance = FeatureUtils.ComputeCutDistance(codes);
 
                     var ctx = new FeatureContext
@@ -204,6 +217,36 @@ public sealed class CincinnatiSheetWriter
             w.WriteLine("M47");
     }
 
+    private void WriteHoleSubprogramCall(TextWriter w, SubProgramCall call, int featureIndex, bool isLastFeature)
+    {
+        var postSubNum = _holeSubprograms != null && _holeSubprograms.TryGetValue(call.Id, out var num)
+            ? num : call.Id;
+
+        var featureNumber = featureIndex == 0
+            ? _config.FeatureLineNumberStart
+            : 1000 + featureIndex + 1;
+
+        // Shift the local origin to the hole center via G52 (manual §1.52).
+        // G52 does not move the nozzle, so the sub-program's first rapid
+        // (the lead-in to the pierce point) takes the tool straight from the
+        // previous feature's end to pierce. The hole sub-program is authored
+        // in hole-local coordinates and resolves to `hole + local` under the
+        // shift. See docs/cincinnati-post-output.md for the full bracket.
+        var sb = new StringBuilder();
+        if (_config.UseLineNumbers)
+            sb.Append($"N{featureNumber} ");
+        sb.Append($"G52 X{_fmt.FormatCoord(call.Offset.X)} Y{_fmt.FormatCoord(call.Offset.Y)}");
+        w.WriteLine(sb.ToString());
+
+        w.WriteLine($"M98 P{postSubNum}");
+
+        // Cancel the local shift (manual §1.52).
+        w.WriteLine("G52 X0 Y0");
+
+        if (!isLastFeature)
+            w.WriteLine("M47");
+    }
+
     private void WritePartsInline(TextWriter w, List<Part> allParts,
         string cutLibrary, string etchLibrary, double sheetDiagonal,
         double plateWidth, double plateLength,
@@ -228,6 +271,14 @@ public sealed class CincinnatiSheetWriter
             var isSafetyHeadraise = partName != lastPartName && lastPartName != "";
             var isLastFeature = i == features.Count - 1;
 
+            // SubProgramCall features are emitted as M98 hole calls
+            if (codes.Count == 1 && codes[0] is SubProgramCall holeCall)
+            {
+                WriteHoleSubprogramCall(w, holeCall, i, isLastFeature);
+                lastPartName = partName;
+                continue;
+            }
+
             var featureNumber = i == 0
                 ? _config.FeatureLineNumberStart
                 : 1000 + i + 1;

OpenNest.Posts.Cincinnati/FeatureUtils.cs

@@ -21,7 +21,16 @@ public static class FeatureUtils
 
         foreach (var code in codes)
         {
-            if (code is RapidMove)
+            if (code is SubProgramCall)
+            {
+                // Flush any pending feature
+                if (current != null)
+                    features.Add(current);
+                // SubProgramCall is its own feature
+                features.Add(new List<ICode> { code });
+                current = null;
+            }
+            else if (code is RapidMove)
             {
                 if (current != null)
                     features.Add(current);

OpenNest.Posts.Cincinnati/MaterialLibraryNameConverter.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+
+namespace OpenNest.Posts.Cincinnati
+{
+    public sealed class MaterialLibraryNameConverter : StringConverter
+    {
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context) => true;
+
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) => false;
+
+        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
+        {
+            var config = context?.Instance as CincinnatiPostConfig;
+            var names = new List<string> { "" };
+
+            if (config?.MaterialLibraries != null)
+            {
+                names.AddRange(config.MaterialLibraries
+                    .Select(e => e.Library)
+                    .Where(s => !string.IsNullOrWhiteSpace(s))
+                    .Distinct(StringComparer.OrdinalIgnoreCase)
+                    .OrderBy(s => s, StringComparer.OrdinalIgnoreCase));
+            }
+
+            return new StandardValuesCollection(names);
+        }
+    }
+}

OpenNest.Posts.Cincinnati/MaterialLibraryResolver.cs

@@ -10,15 +10,20 @@ public sealed class MaterialLibraryResolver
 
     private readonly List<MaterialLibraryEntry> _materialLibraries;
     private readonly List<EtchLibraryEntry> _etchLibraries;
+    private readonly string _selectedLibrary;
 
     public MaterialLibraryResolver(CincinnatiPostConfig config)
     {
         _materialLibraries = config.MaterialLibraries ?? new List<MaterialLibraryEntry>();
         _etchLibraries = config.EtchLibraries ?? new List<EtchLibraryEntry>();
+        _selectedLibrary = config.SelectedLibrary ?? "";
     }
 
     public string ResolveCutLibrary(string materialName, double thickness, string gas)
     {
+        if (!string.IsNullOrEmpty(_selectedLibrary))
+            return EnsureLibExtension(_selectedLibrary);
+
         var entry = _materialLibraries.FirstOrDefault(e =>
             string.Equals(e.Material, materialName, StringComparison.OrdinalIgnoreCase) &&
             System.Math.Abs(e.Thickness - thickness) <= ThicknessTolerance &&

OpenNest.Posts.Cincinnati/OpenNest.Posts.Cincinnati.csproj

@@ -6,11 +6,19 @@
   <ItemGroup>
     <ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <None Update="OpenNest.Posts.Cincinnati.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
   <Target Name="CopyToPostsDir" AfterTargets="Build">
     <PropertyGroup>
       <PostsDir>..\OpenNest\bin\$(Configuration)\$(TargetFramework)\Posts\</PostsDir>
+      <ConfigJson>$(MSBuildProjectDirectory)\OpenNest.Posts.Cincinnati.json</ConfigJson>
+      <DeployedConfigJson>$(PostsDir)OpenNest.Posts.Cincinnati.json</DeployedConfigJson>
     </PropertyGroup>
     <MakeDir Directories="$(PostsDir)" />
     <Copy SourceFiles="$(TargetPath)" DestinationFolder="$(PostsDir)" SkipUnchangedFiles="true" ContinueOnError="true" />
+    <Copy SourceFiles="$(ConfigJson)" DestinationFolder="$(PostsDir)" SkipUnchangedFiles="true" ContinueOnError="true" Condition="!Exists('$(DeployedConfigJson)')" />
   </Target>
 </Project>