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

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

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

.gitignore

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

CLAUDE.md

@@ -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;
@@ -30,15 +28,21 @@ public static class NestRunner
             if (!File.Exists(part.DxfPath))
                 throw new FileNotFoundException($"DXF file not found: {part.DxfPath}", part.DxfPath);
 
-            var geometry = Dxf.GetGeometry(part.DxfPath);
+            Drawing drawing;
-            if (geometry.Count == 0)
+            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;
@@ -241,25 +240,15 @@ static class NestConsole
 
     static Drawing ImportDxf(string path)
     {
-        var geometry = Dxf.GetGeometry(path);
+        try
-
-        if (geometry.Count == 0)
         {
-            Console.Error.WriteLine($"Error: failed to read DXF file or no geometry found: {path}");
+            return CadImporter.ImportDrawing(path);
+        }
+        catch (System.Exception ex)
+        {
+            Console.Error.WriteLine($"Error: failed to import DXF '{path}': {ex.Message}");
             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)

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,14 +26,43 @@ namespace OpenNest.CNC.CuttingStrategy
 
             var profile = new ShapeProfile(entities);
 
-            // Forward pass: sequence cutouts nearest-neighbor from perimeter
+            // Start from the bounding box corner opposite the origin (max X, max Y)
-            var perimeterPoint = profile.Perimeter.ClosestPointTo(approachPoint, out _);
+            var bbox = entities.GetBoundingBox();
-            var orderedCutouts = SequenceCutouts(profile.Cutouts, perimeterPoint);
+            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
+            var perimeterSeed = profile.Perimeter.ClosestPointTo(seedPoint, out _);
-            // so each lead-in faces the next cutout to be cut, not the previous
+            var cutoutEntries = ResolveLeadInPoints(orderedCutouts, perimeterSeed);
-            var cutoutEntries = ResolveLeadInPoints(orderedCutouts, perimeterPoint);
+
+            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);
 
@@ -36,9 +71,6 @@ namespace OpenNest.CNC.CuttingStrategy
             foreach (var entry in cutoutEntries)
                 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);
 
             result.Mode = Mode.Incremental;
@@ -187,6 +219,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 +263,62 @@ 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);
+
+                if (Parameters.TabsEnabled && Parameters.TabConfig != null)
+                    reindexed = TrimShapeForTab(reindexed, relativePoint, Parameters.TabConfig.Size);
+
+                subPgm.Codes.AddRange(ConvertShapeToMoves(reindexed, relativePoint));
+                subPgm.Codes.AddRange(leadOut.Generate(relativePoint, normal, winding));
+                subPgm.Mode = Mode.Incremental;
+
+                // Deduplicate: check if an identical sub-program already exists
+                var key = ComputeSubProgramKey(circle.Radius, normal);
+                if (!program.SubPrograms.ContainsKey(key))
+                    program.SubPrograms[key] = subPgm;
+
+                program.Codes.Add(new SubProgramCall
+                {
+                    Id = key,
+                    Program = program.SubPrograms[key],
+                    Offset = holeCenter
+                });
+
+                return;
+            }
+
             program.Codes.AddRange(leadIn.Generate(point, normal, winding));
 
-            var reindexed = shape.ReindexAt(point, entity);
+            var reindexedShape = shape.ReindexAt(point, entity);
 
             if (Parameters.TabsEnabled && Parameters.TabConfig != null)
-                reindexed = TrimShapeForTab(reindexed, point, Parameters.TabConfig.Size);
+                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));
         }
 

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/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;
+                                endpt = frameOrigin + arc.EndPoint;
-                                centerpt = arc.CenterPoint;
+                                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/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/Converters/ConvertMode.cs

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

OpenNest.Core/Converters/ConvertProgram.cs

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

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/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;

OpenNest.Engine/BestFit/PairEvaluator.cs

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

OpenNest.Engine/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 part = sp.Part;
+            var piercePoints = new Vector[sequenced.Count];
+            var currentPoint = exitPoint;
+
+            for (var i = 0; i < sequenced.Count; i++)
+            {
+                var part = sequenced[i].Part;
 
                 if (part.LeadInsLocked)
                 {
+                    piercePoints[i] = GetPiercePoint(part);
                     currentPoint = part.Location;
                     continue;
                 }
@@ -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/PlateProcessor.cs

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

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.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,42 @@
+using System.Collections.Generic;
+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; }
+    }
+}

OpenNest.IO/CadImporter.cs

@@ -0,0 +1,140 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using OpenNest.Bending;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.IO.Bending;
+
+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);
+
+            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),
+            };
+        }
+
+        /// <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;
+        }
+    }
+}

OpenNest.IO/NestReader.cs

@@ -71,10 +71,68 @@ 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 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>)>();

OpenNest.IO/NestWriter.cs

@@ -308,9 +308,33 @@ namespace OpenNest.IO
                 WriteDrawing(stream, kvp.Value);
 
                 var entry = zipArchive.CreateEntry(name);
-                using var entryStream = entry.Open();
+                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)
@@ -448,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/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,24 +94,18 @@ namespace OpenNest.Mcp.Tools
             if (!File.Exists(path))
                 return $"Error: file not found: {path}";
 
-            var geometry = Dxf.GetGeometry(path);
+            try
-
+            {
-            if (geometry.Count == 0)
+                var drawing = CadImporter.ImportDrawing(path, new CadImportOptions { Name = name });
-                return "Error: failed to read DXF file or no geometry found";
-
-            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();
+                var bbox = drawing.Program.BoundingBox();
-            return $"Imported drawing '{drawingName}': bbox={bbox.Width:F2} x {bbox.Length:F2}";
+                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>

OpenNest.Posts.Cincinnati/OpenNest.Posts.Cincinnati.json

@@ -0,0 +1,163 @@
+{
+  "ConfigurationName": "CL940",
+  "PostedUnits": "Inches",
+  "PostedAccuracy": 4,
+  "UseLineNumbers": true,
+  "FeatureLineNumberStart": 1,
+  "UseSheetSubprograms": true,
+  "SheetSubprogramStart": 101,
+  "UsePartSubprograms": false,
+  "PartSubprogramStart": 200,
+  "VariableDeclarationSubprogram": 100,
+  "CoordModeBetweenParts": "G92",
+  "ProcessParameterMode": "LibraryFile",
+  "DefaultAssistGas": "O2",
+  "DefaultEtchGas": "N2",
+  "UseExactStopMode": false,
+  "UseSpeedGas": false,
+  "UseAntiDive": true,
+  "UseSmartRapids": false,
+  "KerfCompensation": "ControllerSide",
+  "DefaultKerfSide": "Left",
+  "InteriorM47": "Always",
+  "ExteriorM47": "Always",
+  "M47OverrideDistanceThreshold": null,
+  "SafetyHeadraiseDistance": 2000,
+  "PalletExchange": "EndOfSheet",
+  "LeadInFeedratePercent": 0.5,
+  "LeadInArcLine2FeedratePercent": 0.5,
+  "LeadOutFeedratePercent": 0.5,
+  "CircleFeedrateMultiplier": 0.8,
+  "ArcFeedrate": "None",
+  "ArcFeedrateRanges": [
+    { "MaxRadius": 0.125, "FeedratePercent": 0.25, "VariableNumber": 123 },
+    { "MaxRadius": 0.75, "FeedratePercent": 0.5, "VariableNumber": 124 },
+    { "MaxRadius": 4.5, "FeedratePercent": 0.8, "VariableNumber": 125 }
+  ],
+  "UserVariableStart": 200,
+  "SheetWidthVariable": 110,
+  "SheetLengthVariable": 111,
+  "MaterialLibraries": [
+    { "Material": "Aluminum", "Thickness": 0.032, "Gas": "AIR", "Library": "AL032AIR" },
+    { "Material": "Aluminum", "Thickness": 0.032, "Gas": "N2", "Library": "AL032N2" },
+    { "Material": "Aluminum", "Thickness": 0.032, "Gas": "O2", "Library": "AL032O2" },
+    { "Material": "Aluminum", "Thickness": 0.050, "Gas": "AIR", "Library": "AL050AIR" },
+    { "Material": "Aluminum", "Thickness": 0.050, "Gas": "N2", "Library": "AL050N2" },
+    { "Material": "Aluminum", "Thickness": 0.050, "Gas": "O2", "Library": "AL050O2" },
+    { "Material": "Aluminum", "Thickness": 0.063, "Gas": "AIR", "Library": "AL063AIR" },
+    { "Material": "Aluminum", "Thickness": 0.063, "Gas": "N2", "Library": "AL063N2" },
+    { "Material": "Aluminum", "Thickness": 0.063, "Gas": "O2", "Library": "AL063O2" },
+    { "Material": "Aluminum", "Thickness": 0.080, "Gas": "AIR", "Library": "AL080AIR" },
+    { "Material": "Aluminum", "Thickness": 0.080, "Gas": "N2", "Library": "AL080N2" },
+    { "Material": "Aluminum", "Thickness": 0.080, "Gas": "O2", "Library": "AL080O2" },
+    { "Material": "Aluminum", "Thickness": 0.090, "Gas": "AIR", "Library": "AL090AIR" },
+    { "Material": "Aluminum", "Thickness": 0.090, "Gas": "N2", "Library": "AL090N2" },
+    { "Material": "Aluminum", "Thickness": 0.090, "Gas": "O2", "Library": "AL090O2" },
+    { "Material": "Aluminum", "Thickness": 0.100, "Gas": "AIR", "Library": "AL100AIR" },
+    { "Material": "Aluminum", "Thickness": 0.100, "Gas": "N2", "Library": "AL100N2" },
+    { "Material": "Aluminum", "Thickness": 0.100, "Gas": "O2", "Library": "AL100O2" },
+    { "Material": "Aluminum", "Thickness": 0.125, "Gas": "AIR", "Library": "AL125AIR" },
+    { "Material": "Aluminum", "Thickness": 0.125, "Gas": "N2", "Library": "AL125N2" },
+    { "Material": "Aluminum", "Thickness": 0.125, "Gas": "O2", "Library": "AL125O2" },
+    { "Material": "Aluminum", "Thickness": 0.190, "Gas": "AIR", "Library": "AL190AIR" },
+    { "Material": "Aluminum", "Thickness": 0.190, "Gas": "N2", "Library": "AL190N2" },
+    { "Material": "Aluminum", "Thickness": 0.190, "Gas": "O2", "Library": "AL190O2" },
+    { "Material": "Aluminum", "Thickness": 0.250, "Gas": "AIR", "Library": "AL250AIR" },
+    { "Material": "Aluminum", "Thickness": 0.250, "Gas": "N2", "Library": "AL250N2" },
+    { "Material": "Aluminum", "Thickness": 0.250, "Gas": "O2", "Library": "AL250O2" },
+    { "Material": "Aluminum", "Thickness": 0.375, "Gas": "AIR", "Library": "AL375AIR" },
+    { "Material": "Aluminum", "Thickness": 0.375, "Gas": "N2", "Library": "AL375N2" },
+    { "Material": "Aluminum", "Thickness": 0.375, "Gas": "O2", "Library": "AL375O2" },
+    { "Material": "Aluminum", "Thickness": 0.500, "Gas": "AIR", "Library": "AL500AIR" },
+    { "Material": "Aluminum", "Thickness": 0.500, "Gas": "N2", "Library": "AL500N2" },
+    { "Material": "Aluminum", "Thickness": 0.500, "Gas": "O2", "Library": "AL500O2" },
+    { "Material": "Aluminum", "Thickness": 0.625, "Gas": "N2", "Library": "AL625N2" },
+    { "Material": "Aluminum", "Thickness": 0.750, "Gas": "AIR", "Library": "AL750AIR" },
+    { "Material": "Aluminum", "Thickness": 0.750, "Gas": "N2", "Library": "AL750N2" },
+    { "Material": "Aluminum", "Thickness": 0.750, "Gas": "O2", "Library": "AL750O2" },
+    { "Material": "Aluminum", "Thickness": 1.000, "Gas": "AIR", "Library": "AL1000AIR" },
+    { "Material": "Aluminum", "Thickness": 1.000, "Gas": "N2", "Library": "AL1000N2" },
+
+    { "Material": "Galvanized Steel", "Thickness": 0.135, "Gas": "N2", "Library": "GALV135N2" },
+    { "Material": "Galvanized Steel", "Thickness": 0.188, "Gas": "N2", "Library": "GALV188N2" },
+
+    { "Material": "Carbon Steel", "Thickness": 0.036, "Gas": "AIR", "Library": "MS036AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.036, "Gas": "N2", "Library": "MS036N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.048, "Gas": "AIR", "Library": "MS048AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.048, "Gas": "N2", "Library": "MS048N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.060, "Gas": "AIR", "Library": "MS060AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.060, "Gas": "N2", "Library": "MS060N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.075, "Gas": "AIR", "Library": "MS075AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.075, "Gas": "N2", "Library": "MS075N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.075, "Gas": "N2", "Library": "MS075N2FE" },
+    { "Material": "Carbon Steel", "Thickness": 0.090, "Gas": "N2", "Library": "MS090N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.105, "Gas": "AIR", "Library": "MS105AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.105, "Gas": "N2", "Library": "MS105N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.120, "Gas": "AIR", "Library": "MS120AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.120, "Gas": "N2", "Library": "MS120N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.120, "Gas": "N2", "Library": "MS120N2FE" },
+    { "Material": "Carbon Steel", "Thickness": 0.135, "Gas": "AIR", "Library": "MS135AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.135, "Gas": "N2", "Library": "MS135N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.135, "Gas": "N2", "Library": "MS135N2FE" },
+    { "Material": "Carbon Steel", "Thickness": 0.135, "Gas": "N2", "Library": "MS135N2Panel" },
+    { "Material": "Carbon Steel", "Thickness": 0.188, "Gas": "AIR", "Library": "MS188AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.188, "Gas": "N2", "Library": "MS188N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.188, "Gas": "N2", "Library": "MS188N2FLOORPLATE" },
+    { "Material": "Carbon Steel", "Thickness": 0.188, "Gas": "O2", "Library": "MS188O2" },
+    { "Material": "Carbon Steel", "Thickness": 0.250, "Gas": "AIR", "Library": "MS250AIR" },
+    { "Material": "Carbon Steel", "Thickness": 0.250, "Gas": "N2", "Library": "MS250N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.250, "Gas": "N2", "Library": "MS250N2FLOORPLATE" },
+    { "Material": "Carbon Steel", "Thickness": 0.250, "Gas": "O2", "Library": "MS250O2" },
+    { "Material": "Carbon Steel", "Thickness": 0.313, "Gas": "O2", "Library": "MS313O2" },
+    { "Material": "Carbon Steel", "Thickness": 0.375, "Gas": "O2", "Library": "MS375O2" },
+    { "Material": "Carbon Steel", "Thickness": 0.500, "Gas": "N2", "Library": "MS500N2" },
+    { "Material": "Carbon Steel", "Thickness": 0.500, "Gas": "O2", "Library": "MS500O2" },
+    { "Material": "Carbon Steel", "Thickness": 0.625, "Gas": "O2", "Library": "MS625O2" },
+    { "Material": "Carbon Steel", "Thickness": 0.750, "Gas": "O2", "Library": "MS750O2" },
+    { "Material": "Carbon Steel", "Thickness": 1.000, "Gas": "O2", "Library": "MS1000O2" },
+
+    { "Material": "Stainless Steel", "Thickness": 0.036, "Gas": "AIR", "Library": "SS036AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.036, "Gas": "N2", "Library": "SS036N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.048, "Gas": "AIR", "Library": "SS048AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.048, "Gas": "N2", "Library": "SS048N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.060, "Gas": "AIR", "Library": "SS060AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.060, "Gas": "N2", "Library": "SS060N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.075, "Gas": "AIR", "Library": "SS075AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.075, "Gas": "N2", "Library": "SS075N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.075, "Gas": "N2", "Library": "SS075N2FE" },
+    { "Material": "Stainless Steel", "Thickness": 0.105, "Gas": "AIR", "Library": "SS105AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.105, "Gas": "N2", "Library": "SS105N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.105, "Gas": "N2", "Library": "SS105N2FE" },
+    { "Material": "Stainless Steel", "Thickness": 0.120, "Gas": "AIR", "Library": "SS120AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.120, "Gas": "N2", "Library": "SS120N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.120, "Gas": "N2", "Library": "SS120N2FE" },
+    { "Material": "Stainless Steel", "Thickness": 0.135, "Gas": "AIR", "Library": "SS135AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.135, "Gas": "N2", "Library": "SS135N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.135, "Gas": "N2", "Library": "SS135N2FE" },
+    { "Material": "Stainless Steel", "Thickness": 0.188, "Gas": "AIR", "Library": "SS188AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.188, "Gas": "N2", "Library": "SS188N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.250, "Gas": "AIR", "Library": "SS250AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.250, "Gas": "N2", "Library": "SS250N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.313, "Gas": "N2", "Library": "SS313N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.375, "Gas": "AIR", "Library": "SS375AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.375, "Gas": "N2", "Library": "SS375N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.500, "Gas": "AIR", "Library": "SS500AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.500, "Gas": "N2", "Library": "SS500N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.625, "Gas": "N2", "Library": "SS625N2" },
+    { "Material": "Stainless Steel", "Thickness": 0.750, "Gas": "AIR", "Library": "SS750AIR" },
+    { "Material": "Stainless Steel", "Thickness": 0.750, "Gas": "N2", "Library": "SS750N2" },
+    { "Material": "Stainless Steel", "Thickness": 1.000, "Gas": "AIR", "Library": "SS1000AIR" },
+    { "Material": "Stainless Steel", "Thickness": 1.000, "Gas": "N2", "Library": "SS1000N2" },
+
+    { "Material": "Phenolic", "Thickness": 0.0, "Gas": "", "Library": "Phenolic" },
+    { "Material": "Gasket", "Thickness": 0.250, "Gas": "N2", "Library": "GASKET250N2" }
+  ],
+  "EtchLibraries": [
+    { "Gas": "AIR", "Library": "EtchAIR" },
+    { "Gas": "N2", "Library": "EtchN2" },
+    { "Gas": "N2", "Library": "EtchN2_fast" },
+    { "Gas": "N2", "Library": "Etchn2_no_mark_pvc" },
+    { "Gas": "O2", "Library": "EtchO2" },
+    { "Gas": "O2", "Library": "ETCHO2FINE" }
+  ]
+}

OpenNest.Tests/Converters/SubProgramExpansionTests.cs

@@ -0,0 +1,55 @@
+using OpenNest.CNC;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+
+namespace OpenNest.Tests.Converters;
+
+public class SubProgramExpansionTests
+{
+    [Fact]
+    public void ToGeometry_ExpandsSubProgramCall_WithOffset()
+    {
+        // Sub-program: a small line relative to (0,0)
+        var sub = new Program(Mode.Incremental);
+        sub.Codes.Add(new LinearMove(0.5, 0));
+
+        // Main program: call sub at offset (10,20)
+        var main = new Program(Mode.Absolute);
+        main.SubPrograms[1] = sub;
+        main.Codes.Add(new SubProgramCall { Id = 1, Program = sub, Offset = new Vector(10, 20) });
+
+        var geometry = ConvertProgram.ToGeometry(main);
+
+        // The sub-program's line should be offset by (10,20)
+        // Sub emits incremental (0.5,0) from current position.
+        // Since offset is (10,20), the line goes from (10,20) to (10.5,20).
+        Assert.True(geometry.Count > 0);
+        var line = geometry.OfType<Line>().FirstOrDefault();
+        Assert.NotNull(line);
+        Assert.Equal(10.5, line.EndPoint.X, 4);
+        Assert.Equal(20, line.EndPoint.Y, 4);
+    }
+
+    [Fact]
+    public void ToGeometry_MultipleSubProgramCalls_DifferentOffsets()
+    {
+        var sub = new Program(Mode.Incremental);
+        sub.Codes.Add(new LinearMove(1, 0));
+
+        var main = new Program(Mode.Absolute);
+        main.SubPrograms[1] = sub;
+        main.Codes.Add(new SubProgramCall { Id = 1, Program = sub, Offset = new Vector(0, 0) });
+        main.Codes.Add(new SubProgramCall { Id = 1, Program = sub, Offset = new Vector(5, 5) });
+
+        var geometry = ConvertProgram.ToGeometry(main);
+        var lines = geometry.OfType<Line>().ToList();
+
+        Assert.Equal(2, lines.Count);
+        // First call at (0,0): line from (0,0) to (1,0)
+        Assert.Equal(1, lines[0].EndPoint.X, 4);
+        Assert.Equal(0, lines[0].EndPoint.Y, 4);
+        // Second call at (5,5): line from (5,5) to (6,5)
+        Assert.Equal(6, lines[1].EndPoint.X, 4);
+        Assert.Equal(5, lines[1].EndPoint.Y, 4);
+    }
+}

OpenNest.Tests/CuttingStrategy/HoleSubProgramTests.cs

@@ -0,0 +1,338 @@
+using OpenNest.CNC;
+using OpenNest.CNC.CuttingStrategy;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using System.Linq;
+
+namespace OpenNest.Tests.CuttingStrategy;
+
+public class HoleSubProgramTests
+{
+    [Fact]
+    public void SubProgramCall_Offset_DefaultsToZero()
+    {
+        var call = new SubProgramCall();
+        Assert.Equal(0, call.Offset.X);
+        Assert.Equal(0, call.Offset.Y);
+    }
+
+    [Fact]
+    public void SubProgramCall_Offset_StoresValue()
+    {
+        var call = new SubProgramCall { Offset = new Vector(1.5, 2.5) };
+        Assert.Equal(1.5, call.Offset.X);
+        Assert.Equal(2.5, call.Offset.Y);
+    }
+
+    [Fact]
+    public void SubProgramCall_Clone_CopiesOffset()
+    {
+        var call = new SubProgramCall { Id = 1, Offset = new Vector(3, 4) };
+        var clone = (SubProgramCall)call.Clone();
+        Assert.Equal(3, clone.Offset.X);
+        Assert.Equal(4, clone.Offset.Y);
+        Assert.Equal(1, clone.Id);
+    }
+
+    [Fact]
+    public void SubProgramCall_ToString_IncludesOffset()
+    {
+        var call = new SubProgramCall { Id = 1000, Offset = new Vector(1.5, 2.5) };
+        var str = call.ToString();
+        Assert.Contains("P1000", str);
+        Assert.Contains("X1.5", str);
+        Assert.Contains("Y2.5", str);
+    }
+
+    [Fact]
+    public void SubProgramCall_ToString_IncludesOffsetAndRotation()
+    {
+        var call = new SubProgramCall { Id = 1000, Offset = new Vector(1.5, 2.5), Rotation = 30 };
+        var str = call.ToString();
+        Assert.Contains("P1000", str);
+        Assert.Contains("X1.5", str);
+        Assert.Contains("Y2.5", str);
+        Assert.Contains("R30", str);
+    }
+
+    [Fact]
+    public void SubProgramCall_ToString_OmitsZeroFields()
+    {
+        var call = new SubProgramCall { Id = 1000 };
+        var str = call.ToString();
+        Assert.Equal("G65 P1000", str);
+    }
+
+    [Fact]
+    public void Program_SubPrograms_EmptyByDefault()
+    {
+        var pgm = new Program();
+        Assert.NotNull(pgm.SubPrograms);
+        Assert.Empty(pgm.SubPrograms);
+    }
+
+    [Fact]
+    public void Program_SubPrograms_StoresAndRetrieves()
+    {
+        var pgm = new Program();
+        var sub = new Program(Mode.Incremental);
+        sub.Codes.Add(new LinearMove(0.1, 0.2));
+
+        pgm.SubPrograms[1] = sub;
+
+        Assert.Single(pgm.SubPrograms);
+        Assert.Same(sub, pgm.SubPrograms[1]);
+    }
+
+    [Fact]
+    public void Program_Clone_DeepCopiesSubPrograms()
+    {
+        var pgm = new Program();
+        var sub = new Program(Mode.Incremental);
+        sub.Codes.Add(new LinearMove(0.1, 0.2));
+        pgm.SubPrograms[1] = sub;
+
+        var clone = (Program)pgm.Clone();
+
+        Assert.Single(clone.SubPrograms);
+        Assert.NotSame(sub, clone.SubPrograms[1]);
+        Assert.Equal(Mode.Incremental, clone.SubPrograms[1].Mode);
+    }
+
+    [Fact]
+    public void Apply_CircleHole_EmitsSubProgramCall()
+    {
+        // Create a program with a square perimeter and a circle hole at (5, 5) radius 0.5
+        var pgm = new Program(Mode.Absolute);
+        // Square perimeter
+        pgm.Codes.Add(new RapidMove(0, 0));
+        pgm.Codes.Add(new LinearMove(0, 10));
+        pgm.Codes.Add(new LinearMove(10, 10));
+        pgm.Codes.Add(new LinearMove(10, 0));
+        pgm.Codes.Add(new LinearMove(0, 0));
+        // Circle hole at (5, 5) radius 0.5
+        pgm.Codes.Add(new RapidMove(5.5, 5));
+        pgm.Codes.Add(new ArcMove(new Vector(5.5, 5), new Vector(5, 5), RotationType.CW));
+
+        var strategy = new ContourCuttingStrategy
+        {
+            Parameters = new CuttingParameters
+            {
+                ArcCircleLeadIn = new LineLeadIn { Length = 0.125, ApproachAngle = 90 },
+                ArcCircleLeadOut = new NoLeadOut()
+            }
+        };
+
+        var result = strategy.Apply(pgm, new Vector(10, 10));
+
+        // Should contain at least one SubProgramCall
+        var calls = result.Program.Codes.OfType<SubProgramCall>().ToList();
+        Assert.Single(calls);
+
+        // The call's offset should be approximately at the hole center (5, 5)
+        var call = calls[0];
+        Assert.Equal(5, call.Offset.X, 1);
+        Assert.Equal(5, call.Offset.Y, 1);
+
+        // The parent program should have a sub-program registered
+        Assert.True(result.Program.SubPrograms.ContainsKey(call.Id));
+    }
+
+    [Fact]
+    public void Apply_TwoIdenticalCircles_ShareSubProgram()
+    {
+        // Square perimeter with two identical circle holes at different positions
+        var pgm = new Program(Mode.Absolute);
+        // Square perimeter
+        pgm.Codes.Add(new RapidMove(0, 0));
+        pgm.Codes.Add(new LinearMove(0, 10));
+        pgm.Codes.Add(new LinearMove(10, 10));
+        pgm.Codes.Add(new LinearMove(10, 0));
+        pgm.Codes.Add(new LinearMove(0, 0));
+        // Circle 1 at (2, 2) radius 0.5
+        pgm.Codes.Add(new RapidMove(2.5, 2));
+        pgm.Codes.Add(new ArcMove(new Vector(2.5, 2), new Vector(2, 2), RotationType.CW));
+        // Circle 2 at (6, 6) radius 0.5
+        pgm.Codes.Add(new RapidMove(6.5, 6));
+        pgm.Codes.Add(new ArcMove(new Vector(6.5, 6), new Vector(6, 6), RotationType.CW));
+
+        var strategy = new ContourCuttingStrategy
+        {
+            Parameters = new CuttingParameters
+            {
+                RoundLeadInAngles = true,
+                LeadInAngleIncrement = 5.0,
+                ArcCircleLeadIn = new LineLeadIn { Length = 0.125, ApproachAngle = 90 },
+                ArcCircleLeadOut = new NoLeadOut()
+            }
+        };
+
+        var result = strategy.Apply(pgm, new Vector(10, 10));
+
+        var calls = result.Program.Codes.OfType<SubProgramCall>().ToList();
+        Assert.Equal(2, calls.Count);
+
+        // Both calls should reference the same sub-program ID (same radius, same quantized angle)
+        Assert.Equal(calls[0].Id, calls[1].Id);
+
+        // But different offsets
+        Assert.NotEqual(calls[0].Offset.X, calls[1].Offset.X);
+    }
+
+    [Fact]
+    public void Apply_HoleCenters_PreservedInGeometry()
+    {
+        // Square perimeter 10x10 with two circle holes at known positions
+        var holeCenter1 = new Vector(3, 3);
+        var holeCenter2 = new Vector(7, 5);
+        var holeRadius = 0.5;
+
+        var pgm = new Program(Mode.Absolute);
+        // Perimeter
+        pgm.Codes.Add(new RapidMove(0, 0));
+        pgm.Codes.Add(new LinearMove(10, 0));
+        pgm.Codes.Add(new LinearMove(10, 10));
+        pgm.Codes.Add(new LinearMove(0, 10));
+        pgm.Codes.Add(new LinearMove(0, 0));
+        // Hole 1 at (3, 3)
+        pgm.Codes.Add(new RapidMove(holeCenter1.X + holeRadius, holeCenter1.Y));
+        pgm.Codes.Add(new ArcMove(
+            new Vector(holeCenter1.X + holeRadius, holeCenter1.Y),
+            holeCenter1, RotationType.CW));
+        // Hole 2 at (7, 5)
+        pgm.Codes.Add(new RapidMove(holeCenter2.X + holeRadius, holeCenter2.Y));
+        pgm.Codes.Add(new ArcMove(
+            new Vector(holeCenter2.X + holeRadius, holeCenter2.Y),
+            holeCenter2, RotationType.CW));
+
+        var strategy = new ContourCuttingStrategy
+        {
+            Parameters = new CuttingParameters
+            {
+                ArcCircleLeadIn = new LineLeadIn { Length = 0.125, ApproachAngle = 90 },
+                ArcCircleLeadOut = new NoLeadOut()
+            }
+        };
+
+        var result = strategy.Apply(pgm, new Vector(10, 10));
+
+        // Convert to geometry — this is what PlateView renders
+        var geometry = ConvertProgram.ToGeometry(result.Program);
+        var circles = geometry.OfType<Circle>().ToList();
+
+        Assert.Equal(2, circles.Count);
+
+        // Circle centers must match the original hole positions
+        var center1 = circles[0].Center;
+        var center2 = circles[1].Center;
+
+        Assert.Equal(holeCenter1.X, center1.X, 2);
+        Assert.Equal(holeCenter1.Y, center1.Y, 2);
+        Assert.Equal(holeCenter2.X, center2.X, 2);
+        Assert.Equal(holeCenter2.Y, center2.Y, 2);
+    }
+
+    [Fact]
+    public void Part_ApplyLeadIns_HolesAndPerimeter_CorrectPositions()
+    {
+        // Build a drawing with a square and two holes
+        var holeCenter1 = new Vector(3, 3);
+        var holeCenter2 = new Vector(7, 5);
+        var holeRadius = 0.5;
+
+        var pgm = new Program(Mode.Absolute);
+        pgm.Codes.Add(new RapidMove(0, 0));
+        pgm.Codes.Add(new LinearMove(10, 0));
+        pgm.Codes.Add(new LinearMove(10, 10));
+        pgm.Codes.Add(new LinearMove(0, 10));
+        pgm.Codes.Add(new LinearMove(0, 0));
+        pgm.Codes.Add(new RapidMove(holeCenter1.X + holeRadius, holeCenter1.Y));
+        pgm.Codes.Add(new ArcMove(
+            new Vector(holeCenter1.X + holeRadius, holeCenter1.Y),
+            holeCenter1, RotationType.CW));
+        pgm.Codes.Add(new RapidMove(holeCenter2.X + holeRadius, holeCenter2.Y));
+        pgm.Codes.Add(new ArcMove(
+            new Vector(holeCenter2.X + holeRadius, holeCenter2.Y),
+            holeCenter2, RotationType.CW));
+
+        var drawing = new Drawing("TestPart") { Program = pgm };
+        var part = new Part(drawing);
+
+        var parameters = new CuttingParameters
+        {
+            RoundLeadInAngles = true,
+            LeadInAngleIncrement = 5.0,
+            ArcCircleLeadIn = new LineLeadIn { Length = 0.125, ApproachAngle = 90 },
+            ArcCircleLeadOut = new NoLeadOut(),
+            ExternalLeadIn = new LineLeadIn { Length = 0.25, ApproachAngle = 90 },
+            ExternalLeadOut = new NoLeadOut()
+        };
+
+        part.ApplyLeadIns(parameters, new Vector(10, 10));
+
+        // Convert to geometry — this is what PlateView renders
+        var geometry = ConvertProgram.ToGeometry(part.Program);
+        var circles = geometry.OfType<Circle>().ToList();
+        var lines = geometry.OfType<Line>().Where(l => l.Layer != SpecialLayers.Rapid).ToList();
+
+        // Hole circles must be at correct positions
+        Assert.Equal(2, circles.Count);
+        Assert.Equal(holeCenter1.X, circles[0].Center.X, 2);
+        Assert.Equal(holeCenter1.Y, circles[0].Center.Y, 2);
+        Assert.Equal(holeCenter2.X, circles[1].Center.X, 2);
+        Assert.Equal(holeCenter2.Y, circles[1].Center.Y, 2);
+        Assert.Equal(holeRadius, circles[0].Radius, 2);
+        Assert.Equal(holeRadius, circles[1].Radius, 2);
+
+        // Perimeter lines must stay within the original 10x10 bounding box.
+        // This catches the mode conversion bug where perimeter gets shifted
+        // by the last hole's position.
+        foreach (var line in lines)
+        {
+            Assert.True(line.StartPoint.X >= -1 && line.StartPoint.X <= 11,
+                $"Perimeter line start X={line.StartPoint.X} is outside the 10x10 part bounds");
+            Assert.True(line.StartPoint.Y >= -1 && line.StartPoint.Y <= 11,
+                $"Perimeter line start Y={line.StartPoint.Y} is outside the 10x10 part bounds");
+            Assert.True(line.EndPoint.X >= -1 && line.EndPoint.X <= 11,
+                $"Perimeter line end X={line.EndPoint.X} is outside the 10x10 part bounds");
+            Assert.True(line.EndPoint.Y >= -1 && line.EndPoint.Y <= 11,
+                $"Perimeter line end Y={line.EndPoint.Y} is outside the 10x10 part bounds");
+        }
+    }
+
+    [Fact]
+    public void Program_BoundingBox_IncludesSubProgramOffset()
+    {
+        var sub = new Program(Mode.Incremental);
+        sub.Codes.Add(new LinearMove(1, 0));
+
+        var main = new Program(Mode.Absolute);
+        main.SubPrograms[1] = sub;
+        main.Codes.Add(new SubProgramCall { Id = 1, Program = sub, Offset = new Vector(10, 20) });
+
+        var box = main.BoundingBox();
+
+        // Sub-program line goes from (10,20) to (11,20)
+        Assert.True(box.Right >= 11);
+        Assert.True(box.Top >= 20);
+    }
+
+    [Fact]
+    public void Program_Rotate_RotatesSubProgramCallOffsets()
+    {
+        var sub = new Program(Mode.Incremental);
+        sub.Codes.Add(new LinearMove(1, 0));
+
+        var main = new Program(Mode.Absolute);
+        main.SubPrograms[1] = sub;
+        main.Codes.Add(new SubProgramCall { Id = 1, Program = sub, Offset = new Vector(10, 0) });
+
+        // Rotate 90 degrees CCW around origin
+        main.Rotate(System.Math.PI / 2);
+
+        var call = main.Codes.OfType<SubProgramCall>().First();
+        // (10, 0) rotated 90 CCW = (0, 10)
+        Assert.Equal(0, call.Offset.X, 1);
+        Assert.Equal(10, call.Offset.Y, 1);
+    }
+}

OpenNest.Tests/IO/CadImporterTests.cs

@@ -0,0 +1,138 @@
+using System.IO;
+using System.Linq;
+using OpenNest.IO;
+using Xunit;
+
+namespace OpenNest.Tests.IO
+{
+    public class CadImporterTests
+    {
+        private static string TestDxf =>
+            Path.Combine("Bending", "TestData", "4526 A14 PT11.dxf");
+
+        [Fact]
+        public void Import_LoadsEntitiesAndDetectsBends()
+        {
+            var result = CadImporter.Import(TestDxf);
+
+            Assert.NotNull(result);
+            Assert.NotEmpty(result.Entities);
+            Assert.NotNull(result.Bends);
+            Assert.NotNull(result.Bounds);
+            Assert.Equal(TestDxf, result.SourcePath);
+            Assert.Equal("4526 A14 PT11", result.Name);
+        }
+
+        [Fact]
+        public void Import_WhenDetectBendsFalse_ReturnsEmptyBends()
+        {
+            var result = CadImporter.Import(TestDxf, new CadImportOptions { DetectBends = false });
+
+            Assert.Empty(result.Bends);
+        }
+
+        [Fact]
+        public void Import_WhenNameOverrideProvided_UsesOverride()
+        {
+            var result = CadImporter.Import(TestDxf, new CadImportOptions { Name = "custom" });
+
+            Assert.Equal("custom", result.Name);
+        }
+
+        [Fact]
+        public void Import_WhenNamedDetectorDoesNotExist_ReturnsEmptyBends()
+        {
+            // Exercises the named-detector branch: when BendDetectorName doesn't
+            // match any registered detector, bends should be an empty list
+            // (not a crash, and no fall-through to auto-detect).
+            var result = CadImporter.Import(TestDxf,
+                new CadImportOptions { BendDetectorName = "__nonexistent__" });
+
+            Assert.Empty(result.Bends);
+        }
+
+        [Fact]
+        public void BuildDrawing_ProducesDrawingWithProgramAndMetadata()
+        {
+            var result = CadImporter.Import(TestDxf);
+
+            var drawing = CadImporter.BuildDrawing(
+                result,
+                result.Entities,
+                result.Bends,
+                quantity: 5,
+                customer: "ACME",
+                editedProgram: null);
+
+            Assert.NotNull(drawing);
+            Assert.Equal("4526 A14 PT11", drawing.Name);
+            Assert.Equal("ACME", drawing.Customer);
+            Assert.Equal(5, drawing.Quantity.Required);
+            Assert.Equal(TestDxf, drawing.Source.Path);
+            Assert.NotNull(drawing.Program);
+            Assert.NotEmpty(drawing.Program.Codes);
+            Assert.NotNull(drawing.SourceEntities);
+            Assert.NotEmpty(drawing.SourceEntities);
+        }
+
+        [Fact]
+        public void BuildDrawing_ExtractsFirstRapidAsSourceOffset()
+        {
+            var result = CadImporter.Import(TestDxf);
+
+            var drawing = CadImporter.BuildDrawing(result, result.Entities, result.Bends,
+                quantity: 1, customer: null, editedProgram: null);
+
+            Assert.NotNull(drawing.Source.Offset);
+            // After offset extraction, the program's first rapid must start at origin.
+            var firstRapid = (OpenNest.CNC.RapidMove)drawing.Program.Codes[0];
+            Assert.Equal(0, firstRapid.EndPoint.X, 6);
+            Assert.Equal(0, firstRapid.EndPoint.Y, 6);
+        }
+
+        [Fact]
+        public void BuildDrawing_WhenEntityHidden_TracksSuppressedId()
+        {
+            var result = CadImporter.Import(TestDxf);
+            // Suppress the first non-bend-source entity
+            var bendSources = result.Bends
+                .Where(b => b.SourceEntity != null)
+                .Select(b => b.SourceEntity)
+                .ToHashSet();
+            var hidden = result.Entities.First(e => !bendSources.Contains(e));
+            hidden.IsVisible = false;
+
+            var drawing = CadImporter.BuildDrawing(result, result.Entities, result.Bends,
+                quantity: 1, customer: null, editedProgram: null);
+
+            Assert.Contains(hidden.Id, drawing.SuppressedEntityIds);
+        }
+
+        [Fact]
+        public void BuildDrawing_WhenEditedProgramProvided_UsesEditedProgram()
+        {
+            var result = CadImporter.Import(TestDxf);
+            var edited = new OpenNest.CNC.Program();
+            edited.MoveTo(new OpenNest.Geometry.Vector(0, 0));
+
+            var drawing = CadImporter.BuildDrawing(result, result.Entities, result.Bends,
+                quantity: 1, customer: null, editedProgram: edited);
+
+            Assert.Same(edited, drawing.Program);
+        }
+
+        [Fact]
+        public void ImportDrawing_ComposesImportAndBuild()
+        {
+            var drawing = CadImporter.ImportDrawing(TestDxf,
+                new CadImportOptions { Quantity = 3, Customer = "ACME" });
+
+            Assert.NotNull(drawing);
+            Assert.Equal("4526 A14 PT11", drawing.Name);
+            Assert.Equal(3, drawing.Quantity.Required);
+            Assert.Equal("ACME", drawing.Customer);
+            Assert.NotNull(drawing.Program);
+            Assert.NotNull(drawing.SourceEntities);
+        }
+    }
+}

OpenNest.Tests/IO/SubProgramSerializationTests.cs

@@ -0,0 +1,75 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using OpenNest.IO;
+
+namespace OpenNest.Tests.IO;
+
+public class SubProgramSerializationTests
+{
+    [Fact]
+    public void NestWriter_WritesSubProgramCall_WithOffset()
+    {
+        var nest = CreateNestWithHoleSubProgram();
+
+        using var stream = new MemoryStream();
+        var writer = new NestWriter(nest);
+        writer.Write(stream);
+        stream.Position = 0;
+
+        var reader = new NestReader(stream);
+        var loaded = reader.Read();
+
+        var drawing = loaded.Drawings.First();
+        var calls = drawing.Program.Codes.OfType<SubProgramCall>().ToList();
+        Assert.Single(calls);
+        Assert.Equal(5, calls[0].Offset.X, 1);
+        Assert.Equal(5, calls[0].Offset.Y, 1);
+    }
+
+    [Fact]
+    public void NestWriter_WritesSubPrograms_AndRestoresOnLoad()
+    {
+        var nest = CreateNestWithHoleSubProgram();
+
+        using var stream = new MemoryStream();
+        var writer = new NestWriter(nest);
+        writer.Write(stream);
+        stream.Position = 0;
+
+        var reader = new NestReader(stream);
+        var loaded = reader.Read();
+
+        var drawing = loaded.Drawings.First();
+        Assert.True(drawing.Program.SubPrograms.Count > 0);
+
+        var call = drawing.Program.Codes.OfType<SubProgramCall>().First();
+        Assert.True(drawing.Program.SubPrograms.ContainsKey(call.Id));
+    }
+
+    private static Nest CreateNestWithHoleSubProgram()
+    {
+        var sub = new Program(Mode.Incremental);
+        sub.Codes.Add(new LinearMove(0.1, 0) { Layer = LayerType.Leadin });
+        sub.Codes.Add(new ArcMove(new Vector(0, 0), new Vector(-0.5, 0), RotationType.CW));
+
+        var pgm = new Program(Mode.Absolute);
+        pgm.SubPrograms[42] = sub;
+        pgm.Codes.Add(new SubProgramCall { Id = 42, Program = sub, Offset = new Vector(5, 5) });
+        // Add perimeter so the drawing has non-zero geometry
+        pgm.Codes.Add(new RapidMove(0, 0));
+        pgm.Codes.Add(new LinearMove(10, 0));
+        pgm.Codes.Add(new LinearMove(10, 10));
+        pgm.Codes.Add(new LinearMove(0, 10));
+        pgm.Codes.Add(new LinearMove(0, 0));
+
+        var drawing = new Drawing("TestPart") { Program = pgm };
+        var nest = new Nest();
+        nest.Drawings.Add(drawing);
+
+        var plate = new Plate { Size = new Size(48, 96) };
+        plate.Parts.Add(new Part(drawing));
+        nest.Plates.Add(plate);
+
+        return nest;
+    }
+}

OpenNest.Training/Program.cs

@@ -1,8 +1,8 @@
 using OpenNest;
 using OpenNest.Engine.BestFit;
 using OpenNest.Engine.ML;
-using OpenNest.Geometry;
 using OpenNest.Gpu;
+using OpenNest.Geometry;
 using OpenNest.IO;
 using OpenNest.Training;
 using System;
@@ -128,17 +128,26 @@ int RunDataCollection(string dir, string dbPath, string saveDir, double s, strin
                 continue;
             }
 
-            var entities = Dxf.GetGeometry(file);
+            Drawing drawing;
-            if (entities.Count == 0)
+            try
+            {
+                drawing = CadImporter.ImportDrawing(file,
+                    new CadImportOptions { DetectBends = false, Name = Path.GetFileName(file) });
+            }
+            catch (System.Exception ex)
+            {
+                Console.WriteLine($" - SKIP ({ex.Message})");
+                skippedGeometry++;
+                continue;
+            }
+
+            if (drawing.Program == null || drawing.Program.Codes.Count == 0)
             {
                 Console.WriteLine(" - SKIP (no geometry)");
                 skippedGeometry++;
                 continue;
             }
 
-            var drawing = new Drawing(Path.GetFileName(file));
-            var normalized = ShapeProfile.NormalizeEntities(entities);
-            drawing.Program = OpenNest.Converters.ConvertGeometry.ToProgram(normalized);
             drawing.UpdateArea();
             drawing.Color = PartColors[colorIndex % PartColors.Length];
             colorIndex++;

OpenNest/Controls/CutDirectionArrows.cs

@@ -9,6 +9,12 @@ namespace OpenNest.Controls
     {
         public static void DrawProgram(Graphics g, DrawControl view, Program pgm, ref Vector pos,
             Pen pen, double spacing, float arrowSize)
+        {
+            DrawProgram(g, view, pgm, pos, ref pos, pen, spacing, arrowSize);
+        }
+
+        private static void DrawProgram(Graphics g, DrawControl view, Program pgm, Vector basePos, ref Vector pos,
+            Pen pen, double spacing, float arrowSize)
         {
             for (var i = 0; i < pgm.Length; ++i)
             {
@@ -18,7 +24,11 @@ namespace OpenNest.Controls
                 {
                     var subpgm = (SubProgramCall)code;
                     if (subpgm.Program != null)
-                        DrawProgram(g, view, subpgm.Program, ref pos, pen, spacing, arrowSize);
+                    {
+                        var holeBase = basePos + subpgm.Offset;
+                        pos = holeBase;
+                        DrawProgram(g, view, subpgm.Program, holeBase, ref pos, pen, spacing, arrowSize);
+                    }
                     continue;
                 }
 
@@ -26,7 +36,7 @@ namespace OpenNest.Controls
 
                 var endpt = pgm.Mode == Mode.Incremental
                     ? motion.EndPoint + pos
-                    : motion.EndPoint;
+                    : motion.EndPoint + basePos;
 
                 if (code.Type == CodeType.LinearMove)
                 {
@@ -41,7 +51,7 @@ namespace OpenNest.Controls
                     {
                         var center = pgm.Mode == Mode.Incremental
                             ? arc.CenterPoint + pos
-                            : arc.CenterPoint;
+                            : arc.CenterPoint + basePos;
                         DrawArcArrows(g, view, pos, endpt, center, arc.Rotation, pen, spacing, arrowSize);
                     }
                 }

OpenNest/Controls/CuttingPanel.cs

@@ -28,6 +28,9 @@ namespace OpenNest.Controls
         private readonly NumericUpDown nudAutoTabMax;
         private readonly NumericUpDown nudPierceClearance;
 
+        private readonly CheckBox chkRoundLeadInAngles;
+        private readonly NumericUpDown nudLeadInAngleIncrement;
+
         private readonly Button btnAutoAssign;
 
         private bool suppressEvents;
@@ -162,7 +165,7 @@ namespace OpenNest.Controls
             {
                 HeaderText = "Pierce",
                 Dock = DockStyle.Top,
-                ExpandedHeight = 60,
+                ExpandedHeight = 90,
                 IsExpanded = true
             };
 
@@ -176,6 +179,34 @@ namespace OpenNest.Controls
             nudPierceClearance = CreateNumeric(130, 3, 0.0625, 0.0625);
             piercePanel.ContentPanel.Controls.Add(nudPierceClearance);
 
+            chkRoundLeadInAngles = new CheckBox
+            {
+                Text = "Round Lead-In Angles",
+                Location = new Point(12, 32),
+                AutoSize = true
+            };
+            chkRoundLeadInAngles.CheckedChanged += (s, e) =>
+            {
+                nudLeadInAngleIncrement.Enabled = chkRoundLeadInAngles.Checked;
+                OnParametersChanged();
+            };
+            piercePanel.ContentPanel.Controls.Add(chkRoundLeadInAngles);
+
+            piercePanel.ContentPanel.Controls.Add(new Label
+            {
+                Text = "Increment:",
+                Location = new Point(175, 34),
+                AutoSize = true
+            });
+
+            nudLeadInAngleIncrement = CreateNumeric(245, 31, 5, 1);
+            nudLeadInAngleIncrement.DecimalPlaces = 0;
+            nudLeadInAngleIncrement.Minimum = 1;
+            nudLeadInAngleIncrement.Maximum = 90;
+            nudLeadInAngleIncrement.Enabled = false;
+            nudLeadInAngleIncrement.ValueChanged += (s, e) => OnParametersChanged();
+            piercePanel.ContentPanel.Controls.Add(nudLeadInAngleIncrement);
+
             // Auto-Assign button — wrapped in a panel for Dock.Top with padding
             btnAutoAssign = new Button
             {
@@ -218,6 +249,8 @@ namespace OpenNest.Controls
                 TabsEnabled = chkTabsEnabled.Checked,
                 TabConfig = new NormalTab { Size = (double)nudTabWidth.Value },
                 PierceClearance = (double)nudPierceClearance.Value,
+                RoundLeadInAngles = chkRoundLeadInAngles.Checked,
+                LeadInAngleIncrement = (double)nudLeadInAngleIncrement.Value,
                 AutoTabMinSize = (double)nudAutoTabMin.Value,
                 AutoTabMaxSize = (double)nudAutoTabMax.Value
             };
@@ -238,6 +271,9 @@ namespace OpenNest.Controls
             if (p.TabConfig != null)
                 nudTabWidth.Value = (decimal)p.TabConfig.Size;
             nudPierceClearance.Value = (decimal)p.PierceClearance;
+            chkRoundLeadInAngles.Checked = p.RoundLeadInAngles;
+            nudLeadInAngleIncrement.Value = (decimal)p.LeadInAngleIncrement;
+            nudLeadInAngleIncrement.Enabled = p.RoundLeadInAngles;
             nudAutoTabMin.Value = (decimal)p.AutoTabMinSize;
             nudAutoTabMax.Value = (decimal)p.AutoTabMaxSize;
 

OpenNest/Controls/PlateRenderer.cs

@@ -395,8 +395,8 @@ namespace OpenNest.Controls
                 var piercePoint = GetFirstPiercePoint(pgm, part.Location);
                 DrawLine(g, pos, piercePoint, view.ColorScheme.RapidPen);
 
-                pos = part.Location;
+                pos = piercePoint;
-                DrawRapids(g, pgm, ref pos, skipFirstRapid: true);
+                DrawRapids(g, pgm, part.Location, ref pos, skipFirstRapid: true);
             }
         }
 
@@ -404,17 +404,18 @@ namespace OpenNest.Controls
         {
             for (var i = 0; i < pgm.Length; i++)
             {
+                if (pgm[i] is SubProgramCall call && call.Program != null)
+                    return GetFirstPiercePoint(call.Program, partLocation + call.Offset);
+
                 if (pgm[i] is Motion motion)
                 {
-                    if (pgm.Mode == Mode.Incremental)
                     return motion.EndPoint + partLocation;
-                    return motion.EndPoint;
                 }
             }
             return partLocation;
         }
 
-        private void DrawRapids(Graphics g, Program pgm, ref Vector pos, bool skipFirstRapid = false)
+        private void DrawRapids(Graphics g, Program pgm, Vector basePos, ref Vector pos, bool skipFirstRapid = false)
         {
             var firstRapidSkipped = false;
 
@@ -422,47 +423,47 @@ namespace OpenNest.Controls
             {
                 var code = pgm[i];
 
-                if (code.Type == CodeType.SubProgramCall)
+                if (code is SubProgramCall { Program: { } program } call)
                 {
-                    var subpgm = (SubProgramCall)code;
+                    // A SubProgramCall is a coordinate-frame shift, not a physical
-                    var program = subpgm.Program;
+                    // rapid to the hole center. The Cincinnati post emits it as a
+                    // G52 bracket, so the physical rapid is the sub-program's first
+                    // motion, which goes straight from here to the lead-in pierce.
+                    // Look ahead for that pierce point and draw the direct rapid,
+                    // then recurse with skipFirstRapid so the sub doesn't also draw
+                    // its first rapid on top. See docs/cincinnati-post-output.md.
+                    var holeBase = basePos + call.Offset;
+                    var firstPierce = GetFirstPiercePoint(program, holeBase);
 
-                    if (program != null)
+                    if (ShouldDrawRapid(skipFirstRapid, ref firstRapidSkipped))
-                        DrawRapids(g, program, ref pos);
+                        DrawLine(g, pos, firstPierce, view.ColorScheme.RapidPen);
+
+                    var subPos = holeBase;
+                    DrawRapids(g, program, holeBase, ref subPos, skipFirstRapid: true);
+                    pos = subPos;
                 }
-                else
+                else if (code is Motion motion)
                 {
-                    var motion = code as Motion;
+                    var endpt = pgm.Mode == Mode.Incremental
+                        ? motion.EndPoint + pos
+                        : motion.EndPoint;
 
-                    if (motion != null)
+                    if (code.Type == CodeType.RapidMove && ShouldDrawRapid(skipFirstRapid, ref firstRapidSkipped))
-                    {
-                        if (pgm.Mode == Mode.Incremental)
-                        {
-                            var endpt = motion.EndPoint + pos;
-
-                            if (code.Type == CodeType.RapidMove)
-                            {
-                                if (skipFirstRapid && !firstRapidSkipped)
-                                    firstRapidSkipped = true;
-                                else
                         DrawLine(g, pos, endpt, view.ColorScheme.RapidPen);
-                            }
+
                     pos = endpt;
                 }
-                        else
+            }
-                        {
+        }
-                            if (code.Type == CodeType.RapidMove)
+
+        private static bool ShouldDrawRapid(bool skipFirstRapid, ref bool firstRapidSkipped)
         {
             if (skipFirstRapid && !firstRapidSkipped)
+            {
                 firstRapidSkipped = true;
-                                else
+                return false;
-                                    DrawLine(g, pos, motion.EndPoint, view.ColorScheme.RapidPen);
-                            }
-                            pos = motion.EndPoint;
-                        }
-                    }
-                }
             }
+            return true;
         }
 
         private void DrawAllPiercePoints(Graphics g)
@@ -475,11 +476,11 @@ namespace OpenNest.Controls
                 var part = view.Plate.Parts[i];
                 var pgm = part.Program;
                 var pos = part.Location;
-                DrawProgramPiercePoints(g, pgm, ref pos, brush, pen);
+                DrawProgramPiercePoints(g, pgm, part.Location, ref pos, brush, pen);
             }
         }
 
-        private void DrawProgramPiercePoints(Graphics g, Program pgm, ref Vector pos, Brush brush, Pen pen)
+        private void DrawProgramPiercePoints(Graphics g, Program pgm, Vector basePos, ref Vector pos, Brush brush, Pen pen)
         {
             for (var i = 0; i < pgm.Length; ++i)
             {
@@ -489,7 +490,11 @@ namespace OpenNest.Controls
                 {
                     var subpgm = (SubProgramCall)code;
                     if (subpgm.Program != null)
-                        DrawProgramPiercePoints(g, subpgm.Program, ref pos, brush, pen);
+                    {
+                        var holeBase = basePos + subpgm.Offset;
+                        pos = holeBase;
+                        DrawProgramPiercePoints(g, subpgm.Program, holeBase, ref pos, brush, pen);
+                    }
                 }
                 else
                 {
@@ -498,7 +503,7 @@ namespace OpenNest.Controls
 
                     var endpt = pgm.Mode == Mode.Incremental
                         ? motion.EndPoint + pos
-                        : motion.EndPoint;
+                        : motion.EndPoint + basePos;
 
                     if (code.Type == CodeType.RapidMove)
                     {

OpenNest/Controls/PlateView.cs

@@ -621,15 +621,21 @@ namespace OpenNest.Controls
 
         private void redrawTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
         {
-            Invalidate();
+            if (IsDisposed || !IsHandleCreated) return;
+            BeginInvoke(new System.Action(Invalidate));
         }
 
         private void hoverTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
+        {
+            if (IsDisposed || !IsHandleCreated) return;
+            BeginInvoke(new System.Action(HoverCheck));
+        }
+
+        private void HoverCheck()
         {
             var graphPt = PointControlToGraph(hoverPoint);
             LayoutPart hitPart = null;
-            try
+
-            {
             for (var i = parts.Count - 1; i >= 0; --i)
             {
                 if (parts[i].Path.GetBounds().Contains(graphPt) &&
@@ -639,12 +645,6 @@ namespace OpenNest.Controls
                     break;
                 }
             }
-            }
-            catch (InvalidOperationException)
-            {
-                // GraphicsPath in use by paint thread — skip this hover tick
-                return;
-            }
 
             hoveredPart = hitPart;
             showTooltip = hitPart != null;

OpenNest/Forms/BomImportForm.cs

@@ -1,9 +1,5 @@
-using OpenNest.Bending;
-using OpenNest.CNC;
-using OpenNest.Converters;
 using OpenNest.Geometry;
 using OpenNest.IO;
-using OpenNest.IO.Bending;
 using OpenNest.IO.Bom;
 using System;
 using System.Collections.Generic;
@@ -470,33 +466,9 @@ namespace OpenNest.Forms
 
                     try
                     {
-                        var result = Dxf.Import(part.DxfPath);
+                        var drawing = CadImporter.ImportDrawing(part.DxfPath,
-
+                            new CadImportOptions { Quantity = part.Qty ?? 1 });
-                        var bends = new List<Bend>();
-                        if (result.Document != null)
-                            bends = BendDetectorRegistry.AutoDetect(result.Document);
-                        Bend.UpdateEtchEntities(result.Entities, bends);
-
-                        var drawingName = Path.GetFileNameWithoutExtension(part.DxfPath);
-                        var drawing = new Drawing(drawingName);
-                        drawing.Color = Drawing.GetNextColor();
-                        drawing.Source.Path = part.DxfPath;
-                        drawing.Quantity.Required = part.Qty ?? 1;
                         drawing.Material = new Material(material);
-                        if (bends.Count > 0)
-                            drawing.Bends.AddRange(bends);
-
-                        var normalized = ShapeProfile.NormalizeEntities(result.Entities);
-                        var pgm = ConvertGeometry.ToProgram(normalized);
-
-                        if (pgm.Codes.Count > 0 && pgm[0].Type == CodeType.RapidMove)
-                        {
-                            var rapid = (RapidMove)pgm[0];
-                            drawing.Source.Offset = rapid.EndPoint;
-                            pgm.Offset(-rapid.EndPoint);
-                        }
-
-                        drawing.Program = pgm;
                         nest.Drawings.Add(drawing);
                     }
                     catch (Exception ex)

OpenNest/Forms/CadConverterForm.cs

@@ -5,7 +5,6 @@ using OpenNest.Converters;
 using OpenNest.Geometry;
 using OpenNest.IO;
 using OpenNest.IO.Bending;
-using OpenNest.Properties;
 using System;
 using System.Collections.Generic;
 using System.Drawing;
@@ -74,36 +73,24 @@ namespace OpenNest.Forms
         {
             try
             {
-                var result = Dxf.Import(file);
+                var options = new CadImportOptions
+                {
+                    BendDetectorName = detectorIndex == 0 ? null : detectorName,
+                };
 
+                var result = CadImporter.Import(file, options);
                 if (result.Entities.Count == 0)
                     return;
 
-                // Compute bounds
-                var bounds = result.Entities.GetBoundingBox();
-
-                // Detect bends (detectorIndex/Name captured on UI thread)
-                var bends = new List<Bend>();
-                if (result.Document != null)
-                {
-                    bends = detectorIndex == 0
-                        ? BendDetectorRegistry.AutoDetect(result.Document)
-                        : BendDetectorRegistry.GetByName(detectorName)
-                            ?.DetectBends(result.Document)
-                          ?? new List<Bend>();
-                }
-
-                Bend.UpdateEtchEntities(result.Entities, bends);
-
                 var item = new FileListItem
                 {
-                    Name = Path.GetFileNameWithoutExtension(file),
+                    Name = result.Name,
                     Entities = result.Entities,
-                    Path = file,
+                    Path = result.SourcePath,
                     Quantity = 1,
                     Customer = string.Empty,
-                    Bends = bends,
+                    Bends = result.Bends,
-                    Bounds = bounds,
+                    Bounds = result.Bounds,
                     EntityCount = result.Entities.Count
                 };
 
@@ -368,7 +355,6 @@ namespace OpenNest.Forms
                 : Path.GetTempPath();
 
             var index = fileList.SelectedIndex;
-            var newItems = new List<string>();
 
             var splitWriter = new SplitDxfWriter();
             var splitItems = new List<FileListItem>();
@@ -381,7 +367,6 @@ namespace OpenNest.Forms
                 var splitPath = GetUniquePath(Path.Combine(writableDir, splitName));
 
                 splitWriter.Write(splitPath, splitDrawing);
-                newItems.Add(splitPath);
 
                 // Re-import geometry but keep bends from the split drawing
                 var result = Dxf.Import(splitPath);
@@ -669,53 +654,35 @@ namespace OpenNest.Forms
 
             foreach (var item in fileList.Items)
             {
-                var entities = item.Entities.Where(e => e.Layer.IsVisible && e.IsVisible).ToList();
+                var visible = item.Entities
-
+                    .Where(e => e.Layer.IsVisible && e.IsVisible)
-                if (entities.Count == 0)
-                    continue;
-
-                var drawing = new Drawing(item.Name);
-                drawing.Color = Drawing.GetNextColor();
-                drawing.Customer = item.Customer;
-                drawing.Source.Path = item.Path;
-                drawing.Quantity.Required = item.Quantity;
-
-                // Copy bends
-                if (item.Bends != null)
-                    drawing.Bends.AddRange(item.Bends);
-
-                var normalized = ShapeProfile.NormalizeEntities(entities);
-                var pgm = ConvertGeometry.ToProgram(normalized);
-                var firstCode = pgm[0];
-
-                if (firstCode.Type == CodeType.RapidMove)
-                {
-                    var rapid = (RapidMove)firstCode;
-                    drawing.Source.Offset = rapid.EndPoint;
-                    pgm.Offset(-rapid.EndPoint);
-                    // Keep the rapid (now at origin) — it marks the contour
-                    // start and is needed by the post for correct pierce placement.
-                }
-
-                if (item == CurrentItem && programEditor.IsDirty && programEditor.Program != null)
-                    drawing.Program = programEditor.Program;
-                else
-                    drawing.Program = pgm;
-
-                // Store all entities with stable GUIDs; track suppressed by ID
-                var bendSources = new HashSet<Entity>(
-                    (item.Bends ?? new List<Bend>())
-                        .Where(b => b.SourceEntity != null)
-                        .Select(b => b.SourceEntity));
-
-                drawing.SourceEntities = item.Entities
-                    .Where(e => !bendSources.Contains(e))
                     .ToList();
 
-                drawing.SuppressedEntityIds = new HashSet<Guid>(
+                if (visible.Count == 0)
-                    drawing.SourceEntities
+                    continue;
-                        .Where(e => !(e.Layer.IsVisible && e.IsVisible))
+
-                        .Select(e => e.Id));
+                // Rebuild a CadImportResult from the FileListItem's current state so
+                // BuildDrawing sees the user's edits (filters, suppressions, new bends).
+                var result = new CadImportResult
+                {
+                    Entities = item.Entities,
+                    Bends = item.Bends ?? new List<Bend>(),
+                    Bounds = item.Bounds,
+                    SourcePath = item.Path,
+                    Name = item.Name,
+                };
+
+                var editedProgram = (item == CurrentItem && programEditor.IsDirty && programEditor.Program != null)
+                    ? programEditor.Program
+                    : null;
+
+                var drawing = CadImporter.BuildDrawing(
+                    result,
+                    visible,
+                    result.Bends,
+                    item.Quantity,
+                    item.Customer,
+                    editedProgram);
 
                 drawings.Add(drawing);
 
@@ -780,9 +747,6 @@ namespace OpenNest.Forms
                 item.SuppressedEntityIds = null;
         }
 
-
-        private static Color GetNextColor() => Drawing.GetNextColor();
-
         private static bool IsDirectoryWritable(string path)
         {
             try

OpenNest/Forms/CuttingParametersSerializer.cs

@@ -24,6 +24,8 @@ namespace OpenNest.Forms
                 TabsEnabled = p.TabsEnabled,
                 TabWidth = p.TabConfig?.Size ?? 0.25,
                 PierceClearance = p.PierceClearance,
+                RoundLeadInAngles = p.RoundLeadInAngles,
+                LeadInAngleIncrement = p.LeadInAngleIncrement,
                 AutoTabMinSize = p.AutoTabMinSize,
                 AutoTabMaxSize = p.AutoTabMaxSize
             };
@@ -47,6 +49,8 @@ namespace OpenNest.Forms
                 TabsEnabled = dto.TabsEnabled,
                 TabConfig = new NormalTab { Size = dto.TabWidth },
                 PierceClearance = dto.PierceClearance,
+                RoundLeadInAngles = dto.RoundLeadInAngles,
+                LeadInAngleIncrement = dto.LeadInAngleIncrement > 0 ? dto.LeadInAngleIncrement : 5.0,
                 AutoTabMinSize = dto.AutoTabMinSize,
                 AutoTabMaxSize = dto.AutoTabMaxSize
             };
@@ -111,6 +115,8 @@ namespace OpenNest.Forms
             public bool TabsEnabled { get; set; }
             public double TabWidth { get; set; }
             public double PierceClearance { get; set; }
+            public bool RoundLeadInAngles { get; set; }
+            public double LeadInAngleIncrement { get; set; }
             public double AutoTabMinSize { get; set; }
             public double AutoTabMaxSize { get; set; }
         }

OpenNest/Forms/EditNestForm.Designer.cs

@@ -81,8 +81,8 @@
             // 
             // tabControl1
             // 
-            tabControl1.Controls.Add(tabPage1);
             tabControl1.Controls.Add(tabPage2);
+            tabControl1.Controls.Add(tabPage1);
             tabControl1.Dock = System.Windows.Forms.DockStyle.Fill;
             tabControl1.ItemSize = new System.Drawing.Size(100, 22);
             tabControl1.Location = new System.Drawing.Point(0, 0);

OpenNest/Forms/EditNestInfoForm.Designer.cs

@@ -63,7 +63,7 @@
             this.textBox2 = new System.Windows.Forms.TextBox();
             this.label5 = new System.Windows.Forms.Label();
             this.labelMaterial = new System.Windows.Forms.Label();
-            this.materialBox = new System.Windows.Forms.TextBox();
+            this.materialBox = new System.Windows.Forms.ComboBox();
             this.tabPage2 = new System.Windows.Forms.TabPage();
             this.tabPage3 = new System.Windows.Forms.TabPage();
             this.notesBox = new System.Windows.Forms.TextBox();
@@ -516,9 +516,10 @@
             // materialBox
             //
             this.materialBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
+            this.materialBox.FormattingEnabled = true;
             this.materialBox.Location = new System.Drawing.Point(135, 159);
             this.materialBox.Name = "materialBox";
-            this.materialBox.Size = new System.Drawing.Size(224, 22);
+            this.materialBox.Size = new System.Drawing.Size(224, 24);
             this.materialBox.TabIndex = 11;
             //
             // label3
@@ -729,6 +730,6 @@
         private System.Windows.Forms.RadioButton radioButton2;
         private System.Windows.Forms.Label label5;
         private System.Windows.Forms.Label labelMaterial;
-        private System.Windows.Forms.TextBox materialBox;
+        private System.Windows.Forms.ComboBox materialBox;
     }
 }

OpenNest/Forms/EditNestInfoForm.cs

@@ -15,6 +15,9 @@ namespace OpenNest.Forms
         {
             InitializeComponent();
 
+            foreach (var name in PostProcessorMaterials.Names)
+                materialBox.Items.Add(name);
+
             timer = new Timer
             {
                 SynchronizingObject = this,

OpenNest/Forms/MainForm.cs

@@ -351,6 +351,9 @@ namespace OpenNest.Forms
                         postProcessorMenuItem.Tag = postProcessor;
                         postProcessorMenuItem.Click += PostProcessor_Click;
                         mnuNestPost.DropDownItems.Add(postProcessorMenuItem);
+
+                        if (postProcessor is IMaterialProvidingPostProcessor materialProvider)
+                            PostProcessorMaterials.AddFrom(materialProvider);
                     }
                 }
             }
@@ -1157,6 +1160,9 @@ namespace OpenNest.Forms
             if (postProcessor == null)
                 return;
 
+            if (postProcessor is IPostProcessorNestAware nestAware)
+                nestAware.PrepareForNest(activeForm.Nest);
+
             if (postProcessor is IConfigurablePostProcessor configurable)
             {
                 using var configForm = new PostProcessorConfigForm(configurable);

OpenNest/GraphicsHelper.cs

@@ -98,6 +98,9 @@ namespace OpenNest
         private static void AddProgramSplit(GraphicsPath cutPath, GraphicsPath leadPath,
             Program pgm, Mode mode, ref Vector curpos)
         {
+            // 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 = pgm.Mode;
 
             for (var i = 0; i < pgm.Length; ++i)
@@ -147,6 +150,7 @@ namespace OpenNest
                         {
                             cutPath.StartFigure();
                             leadPath.StartFigure();
+                            curpos = new Vector(frameOrigin.X + subpgm.Offset.X, frameOrigin.Y + subpgm.Offset.Y);
                             AddProgramSplit(cutPath, leadPath, subpgm.Program, mode, ref curpos);
                         }
                         mode = tmpmode;
@@ -237,6 +241,9 @@ namespace OpenNest
 
         private static void AddProgram(GraphicsPath path, Program pgm, Mode mode, ref Vector curpos)
         {
+            // 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 = pgm.Mode;
             GraphicsPath currentFigure = null;
 
@@ -305,6 +312,7 @@ namespace OpenNest
 
                             if (subpgm.Program != null)
                             {
+                                curpos = new Vector(frameOrigin.X + subpgm.Offset.X, frameOrigin.Y + subpgm.Offset.Y);
                                 AddProgram(path, subpgm.Program, mode, ref curpos);
                             }
 

OpenNest/PostProcessorMaterials.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest
+{
+    public static class PostProcessorMaterials
+    {
+        private static readonly List<string> materials = new();
+
+        public static IReadOnlyList<string> Names => materials;
+
+        public static void AddFrom(IMaterialProvidingPostProcessor provider)
+        {
+            if (provider == null)
+                return;
+
+            foreach (var name in provider.GetMaterialNames())
+            {
+                if (!string.IsNullOrWhiteSpace(name)
+                    && !materials.Contains(name, StringComparer.OrdinalIgnoreCase))
+                {
+                    materials.Add(name);
+                }
+            }
+
+            materials.Sort(StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}

docs/cincinnati-post-output.md

@@ -0,0 +1,212 @@
+# Cincinnati Post Output Reference
+
+Reference for the G-code structure emitted by `OpenNest.Posts.Cincinnati`.
+Every code listed here maps to a section in the Cincinnati Laser Programming
+Manual (`docs/CINCINNATI LASER PROGRAMMING MANUAL.pdf`, EM-423 R-02/11).
+Section numbers in parentheses (e.g. `§1.52`) refer to the manual.
+
+If you add a new emission in the post, either cite the manual section it maps
+to, or flag it here as a known custom extension. "Custom code" in this project
+means something that is not documented in the manual but that the Cincinnati
+control is known to accept — none exist today and we should not introduce any
+without confirming the control behavior.
+
+## Overall file structure
+
+A generated file contains, in order:
+
+1. **Main program** (`CincinnatiPreambleWriter.WriteMainProgram`)
+   Preamble, unit/mode setup, initial library, variable-declaration call, one
+   `M98 P<sheetSubNum>` call per plate quantity, and `M30` to end.
+
+2. **Variable declaration sub-program** (`CincinnatiPreambleWriter.WriteVariableDeclaration`)
+   Machine variables (`#number = value`) used across the nest, terminated
+   with `M99`.
+
+3. **Sheet sub-programs** (`CincinnatiSheetWriter.Write`), one per unique plate
+   layout. A sheet sub-program contains the cutting sequence for a whole
+   plate, either with features inlined or with `M98` calls into part
+   sub-programs.
+
+4. **Part sub-programs** (`CincinnatiPartSubprogramWriter.Write`), one per
+   unique `(drawing, rotation)` pair, only emitted when
+   `Config.UsePartSubprograms` is enabled.
+
+5. **Hole sub-programs** (`CincinnatiPartSubprogramWriter.Write` reused with a
+   `"HOLE"` label), one per unique hole geometry keyed by radius and lead-in
+   normal angle.
+
+Sub-program bodies start with a `:<subNum>` label and end with `M99`.
+
+## Feature blocks
+
+A "feature" is a single contour: lead-in → cut moves → lead-out. Each feature
+block in a sheet or sub-program output follows this order
+(`CincinnatiFeatureWriter.Write`):
+
+1. `G0 X_ Y_` — rapid to the pierce point (§1.00).
+2. Optional part-name comment, only on the first feature of each part.
+3. `G89 P<library>` — load process parameters (§2.89). `P` is a library file
+   name; the `(...)` trailing comment carries speed-class info.
+4. `G84` (cut) or `G85` (etch / no-pierce) — pierce and start cut, or start
+   cut without pierce (§2.84 / §2.85).
+5. `M130 (ANTI DIVE OFF)` — disable anti-dive, only if configured (§3.130).
+6. Contour moves:
+   - `G41` (left) or `G42` (right) kerf compensation on the first cut move
+     (§1.41 / §1.42), suppressed for etch features.
+   - `G1 X_ Y_ [F<feedvar>]` — linear cut move (§1.01). Feedrate references a
+     machine variable such as `#148` and is emitted only when it changes.
+   - `G2 X_ Y_ I_ J_ [F<feedvar>]` (CW) or `G3` (CCW) — arc (§1.02 / §1.03).
+     `I`/`J` are incremental offsets from the current position to the center.
+7. `G40` — cancel kerf compensation (§1.40), only if it was applied.
+8. `M35` (or `M135` if SpeedGas is enabled) — beam off (§3.35 / §3.135).
+9. `M131 (ANTI DIVE ON)` — re-enable anti-dive (§3.131).
+10. `M47` or `M47 P<distance>` — raise Z-axis, unless this is the last feature
+    on the sheet (§3.47). A leading `/` (block delete, §5.6) is prepended when
+    the configured override distance exceeds the default.
+
+Sheet sub-program and sheet-level feature calls add `G92 X#5021 Y#5022`
+(§1.92) at the top so the local origin is anchored to the machine's current
+absolute position (`#5021`/`#5022` are the machine X/Y system variables).
+
+## Sub-program call patterns
+
+There are two distinct call-site patterns, depending on whether the call
+targets a whole-part sub-program or a hole sub-program.
+
+### Part sub-program call (`WriteSubprogramCall`)
+
+Used when `Config.UsePartSubprograms` is enabled. The tool physically rapids
+to the part corner, then G92 sets the current position as the local origin,
+the sub-program executes in its own local coordinate frame, and G92 restores
+the original absolute position after return.
+
+```
+G0 X<left> Y<bottom>          ; rapid to part bounding box corner (§1.00)
+(PART: <name>)
+G92 X0 Y0                     ; set local origin at current position (§1.92)
+M98 P<partSubNum> (<name>)    ; call the part sub-program (§3.98)
+G92 X<left> Y<bottom>         ; restore the sheet coordinate system (§1.92)
+M47                           ; head raise unless this is the last part (§3.47)
+```
+
+This pattern uses G92 because the tool is physically positioned at the part
+corner first. The sub-program's coordinates are part-local, so they are
+interpreted against the new origin until G92 restores the sheet frame.
+
+### Hole sub-program call (`WriteHoleSubprogramCall`)
+
+Used for the `SubProgramCall` codes that a `ContourCuttingStrategy` emits for
+each circular hole. Unlike parts, we do **not** want a physical rapid to the
+hole center before calling — the sub-program's first rapid is the lead-in to
+the pierce point, and the machine should travel directly from the previous
+feature's end to that pierce.
+
+```
+G52 X<hole.x> Y<hole.y>       ; shift local origin to hole center (§1.52)
+M98 P<holeSubNum>             ; call the shared hole sub-program (§3.98)
+G52 X0 Y0                     ; restore the original coordinate system (§1.52)
+M47                           ; head raise unless this is the last feature (§3.47)
+```
+
+G52 specifies the new origin in the current work coordinate system and — per
+§1.52 — "does not move the cutting nozzle". The hole sub-program is written
+in hole-local coordinates (origin at the hole center, produced by
+`ContourCuttingStrategy`), so its first `G0 X_ Y_` resolves to `hole + local`
+in absolute terms. That is the first physical motion, and it takes the tool
+straight from wherever it was to the lead-in pierce point. G52 X0 Y0 cancels
+the shift after `M99` returns control.
+
+## G-code reference
+
+These are every G/M code the post emits, grouped by category. Anything here is
+documented in the programming manual. Anything not here should be audited the
+next time the post is edited.
+
+### Motion modes and contouring
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `G0 X_ Y_` | Rapid traverse | §1.00 |
+| `G1 X_ Y_ F_` | Linear feedrate move | §1.01 |
+| `G2 X_ Y_ I_ J_ F_` | Clockwise arc | §1.02 |
+| `G3 X_ Y_ I_ J_ F_` | Counter-clockwise arc | §1.03 |
+
+### Units and coordinate mode
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `G20` | Inch mode | §1.20 |
+| `G21` | Metric mode | §1.21 |
+| `G90` | Absolute mode | §1.90 |
+
+### Kerf compensation
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `G40` | Cancel kerf compensation | §1.40 |
+| `G41` | Kerf compensation, left side | §1.41 |
+| `G42` | Kerf compensation, right side | §1.42 |
+
+### Work coordinate systems
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `G52 X_ Y_` | Temporary local work coordinate offset. Does not move the tool. `G52 X0 Y0` cancels. | §1.52 |
+| `G92 X_ Y_` | Sets the current tool position to `(X, Y)` in the work coordinate system, implicitly redefining the WCS origin. | §1.92 |
+
+### Exact stop
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `G61` | Exact stop mode | §1.61 |
+
+### Cutting operations (custom Cincinnati G-codes)
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `G84` | Pierce and start cut | §2.84 |
+| `G85` | Start cut without pierce (used for etch) | §2.85 |
+| `G89 P<file>` | Load process parameters from a library file | §2.89 |
+| `G121` | Enable non-stop cutting (Smart Rapids) | §2.121 |
+
+### Program flow
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `M30` | End of main program with rewind | §3.30 |
+| `M98 P_` | Sub-program call. **Takes only `P` and `L` — not `X`/`Y`.** | §3.98 |
+| `M99` | Return from sub-program | §3.99 |
+
+### Machine state
+
+| Code | Description | Manual |
+| --- | --- | --- |
+| `M35` | Beam off | §3.35 |
+| `M42` | Retract Z-axis | §3.42 |
+| `M47 [P<dist>]` | Raise Z-axis, optionally by a distance | §3.47 |
+| `M50` | Switch pallets | §3.50 |
+| `M130` | Anti-dive off | §3.130 |
+| `M131` | Anti-dive on | §3.131 |
+| `M135` | Discharge current off (keeps assist gas on) | §3.135 |
+
+### Comments, labels, and block delete
+
+| Syntax | Description | Manual |
+| --- | --- | --- |
+| `(text)` | Inline comment | §5.4 |
+| `:<number>` | Sub-program label | §3.98 |
+| `/<block>` | Block delete — operator can toggle the line off | §5.6 |
+| `N<number>` | Line number, used by M99 P / GOTO targets | §5.5 |
+
+## System variables referenced
+
+| Variable | Description | Manual |
+| --- | --- | --- |
+| `#148` | Default cut feedrate variable (used in `F#148`) | §2.89 |
+| `#5021` | Current machine X position | §6 (table of system variables) |
+| `#5022` | Current machine Y position | §6 (table of system variables) |
+
+Project-defined variables start at `Config.SheetWidthVariable` /
+`Config.SheetLengthVariable` and at `Config.UserVariableStart`. Those ranges
+are documented in `CincinnatiPostConfig.cs`.