feat: add filter toggle to remnant viewer for showing all remnants

The remnant viewer previously always filtered by smallest part dimension,
hiding large remnants that were narrower than the smallest part. Added a
"Filter by part size" checkbox (on by default) so users can toggle this
off to see all remnants regardless of size.

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

.gitignore

@@ -208,3 +208,7 @@ FakesAssemblies/
 
 # Claude Code
 .claude/
+.superpowers/
+
+# Launch settings
+**/Properties/launchSettings.json

CLAUDE.md

@@ -30,23 +30,25 @@ Domain model, geometry, and CNC primitives organized into namespaces:
 - **Math** (`Math/`, `namespace OpenNest.Math`): `Angle` (radian/degree conversion), `Tolerance` (floating-point comparison), `Trigonometry`, `Generic` (swap utility), `EvenOdd`, `Rounding` (factor-based rounding). Note: `OpenNest.Math` shadows `System.Math` — use `System.Math` fully qualified where both are needed.
 - **CNC/CuttingStrategy** (`CNC/CuttingStrategy/`, `namespace OpenNest.CNC`): `ContourCuttingStrategy` orchestrates cut ordering, lead-ins/lead-outs, and tabs. Includes `LeadIn`/`LeadOut` hierarchies (line, arc, clean-hole variants), `Tab` hierarchy (normal, machine, breaker), and `CuttingParameters`/`AssignmentParameters`/`SequenceParameters` configuration.
 - **Collections** (`Collections/`, `namespace OpenNest.Collections`): `ObservableList<T>`, `DrawingCollection`.
+- **CutOffs** (`namespace OpenNest`): `CutOff` (axis-aligned cut line with position, axis, optional start/end limits), `CutOffAxis` enum (`Horizontal`, `Vertical`), `CutOffSettings` (clearance, overtravel, min segment length, direction), `CutDirection` enum (`TowardOrigin`, `AwayFromOrigin`). Cut-offs generate CNC `Program` objects with trimmed line segments that avoid parts.
+- **Splitting** (`Splitting/`, `namespace OpenNest`): `DrawingSplitter` splits a Drawing into multiple pieces along split lines. `ISplitFeature` strategy pattern with implementations: `StraightSplit` (clean edge), `WeldGapTabSplit` (rectangular tab spacers on one side), `SpikeGrooveSplit` (interlocking spike/V-groove pairs). `AutoSplitCalculator` computes split lines for fit-to-plate and split-by-count modes. Supporting types: `SplitLine`, `SplitParameters`, `SplitFeatureResult`.
 - **Quadrant system**: Plates use quadrants 1-4 (like Cartesian quadrants) to determine coordinate origin placement. This affects bounding box calculation, rotation, and part positioning.
 
 ### OpenNest.Engine (class library, depends on Core)
-Nesting algorithms with a pluggable engine architecture. `NestEngineBase` is the abstract base class; `DefaultNestEngine` (formerly `NestEngine`) provides the multi-phase fill strategy. `NestEngineRegistry` manages available engines (built-in + plugins from `Engines/` directory) and the globally active engine. `AutoNester` handles mixed-part NFP-based nesting with simulated annealing (not yet integrated into the registry).
+Nesting algorithms with a pluggable engine architecture. `NestEngineBase` is the abstract base class; `DefaultNestEngine` (formerly `NestEngine`) provides the multi-phase fill strategy. `NestEngineRegistry` manages available engines (built-in + plugins from `Engines/` directory) and the globally active engine.
 
-- **Engine hierarchy**: `NestEngineBase` (abstract) → `DefaultNestEngine` (Linear, Pairs, RectBestFit, Remainder phases). Custom engines subclass `NestEngineBase` and register via `NestEngineRegistry.Register()` or as plugin DLLs in `Engines/`.
+- **Engine hierarchy**: `NestEngineBase` (abstract) → `DefaultNestEngine` (Linear, Pairs, RectBestFit, Remainder phases) → `VerticalRemnantEngine` (optimizes for right-side drop), `HorizontalRemnantEngine` (optimizes for top-side drop). Custom engines subclass `NestEngineBase` and register via `NestEngineRegistry.Register()` or as plugin DLLs in `Engines/`.
+- **IFillComparer**: Interface enabling engine-specific scoring. `DefaultFillComparer` (count-then-density), `VerticalRemnantComparer` (minimize X-extent), `HorizontalRemnantComparer` (minimize Y-extent). Engines provide their comparer via `CreateComparer()` factory, grouped into `FillPolicy` on `FillContext`.
 - **NestEngineRegistry**: Static registry — `Create(Plate)` factory, `ActiveEngineName` global selection, `LoadPlugins(directory)` for DLL discovery. All callsites use `NestEngineRegistry.Create(plate)` except `BruteForceRunner` which uses `new DefaultNestEngine(plate)` directly for training consistency.
-- **BestFit/**: NFP-based pair evaluation pipeline — `BestFitFinder` orchestrates angle sweeps, `PairEvaluator`/`IPairEvaluator` scores part pairs, `RotationSlideStrategy`/`ISlideComputer` computes slide distances. `BestFitCache` and `BestFitFilter` optimize repeated lookups.
-- **RectanglePacking/**: `FillBestFit` (single-item fill, tries horizontal and vertical orientations), `PackBottomLeft` (multi-item bin packing, sorts by area descending). Both operate on `Bin`/`Item` abstractions.
-- **CirclePacking/**: Alternative packing for circular parts.
-- **ML/**: `AnglePredictor` (ONNX model for predicting good rotation angles), `FeatureExtractor` (part geometry features), `BruteForceRunner` (full angle sweep for training data).
-- `FillLinear`: Grid-based fill with directional sliding.
-- `Compactor`: Post-fill gravity compaction — pushes parts toward a plate edge to close gaps.
-- `FillScore`: Lexicographic comparison struct for fill results (count > utilization > compactness).
+- **Fill/** (`namespace OpenNest.Engine.Fill`): Fill algorithms — `FillLinear` (grid-based), `FillExtents` (extents-based pair tiling), `PairFiller` (interlocking pairs), `ShrinkFiller`, `RemnantFiller`/`RemnantFinder`, `Compactor` (post-fill gravity compaction), `FillScore` (lexicographic comparison: count > utilization > compactness), `Pattern`/`PatternTiler`, `PartBoundary`, `RotationAnalysis`, `AngleCandidateBuilder`, `BestCombination`, `AccumulatingProgress`.
+- **Strategies/** (`namespace OpenNest.Engine.Strategies`): Pluggable fill strategy layer — `IFillStrategy` interface, `FillContext`, `FillStrategyRegistry` (auto-discovers strategies via reflection, supports plugin DLLs), `FillHelpers`. Built-in strategies: `LinearFillStrategy`, `PairsFillStrategy`, `RectBestFitStrategy`, `ExtentsFillStrategy`.
+- **BestFit/** (`namespace OpenNest.Engine.BestFit`): NFP-based pair evaluation pipeline — `BestFitFinder` orchestrates angle sweeps, `PairEvaluator`/`IPairEvaluator` scores part pairs, `RotationSlideStrategy`/`ISlideComputer` computes slide distances. `BestFitCache` and `BestFitFilter` optimize repeated lookups.
+- **RectanglePacking/** (`namespace OpenNest.RectanglePacking`): `FillBestFit` (single-item fill, tries horizontal and vertical orientations), `PackBottomLeft` (multi-item bin packing, sorts by area descending). Both operate on `Bin`/`Item` abstractions.
+- **CirclePacking/** (`namespace OpenNest.CirclePacking`): Alternative packing for circular parts.
+- **Nfp/** (`namespace OpenNest.Engine.Nfp`): Internal NFP-based single-part placement utilities — `AutoNester` (NFP placement with simulated annealing), `BottomLeftFill` (BLF placement), `NfpCache` (computed NFP caching), `SimulatedAnnealing` (optimizer), `INestOptimizer`/`OptimizationResult`. Not exposed as a nest engine; used internally for individual part placement.
+- **ML/** (`namespace OpenNest.Engine.ML`): `AnglePredictor` (ONNX model for predicting good rotation angles), `FeatureExtractor` (part geometry features), `BruteForceRunner` (full angle sweep for training data).
 - `NestItem`: Input to the engine — wraps a `Drawing` with quantity, priority, and rotation constraints.
 - `NestProgress`: Progress reporting model with `NestPhase` enum for UI feedback.
-- `RotationAnalysis`: Analyzes part geometry to determine valid rotation angles.
 
 ### OpenNest.IO (class library, depends on Core)
 File I/O and format conversion. Uses ACadSharp for DXF/DWG support.
@@ -77,19 +79,17 @@ MCP server for Claude Code integration. Exposes nesting operations as MCP tools
 ### OpenNest (WinForms WinExe, depends on Core + Engine + IO)
 The UI application with MDI interface.
 
-- **Forms/**: `MainForm` (MDI parent), `EditNestForm` (MDI child per nest), plus dialogs for plate editing, auto-nesting, DXF conversion, cut parameters, etc.
+- **Forms/**: `MainForm` (MDI parent), `EditNestForm` (MDI child per nest), `SplitDrawingForm` (split oversized drawings into smaller pieces, launched from CadConverterForm), plus dialogs for plate editing, auto-nesting, DXF conversion, cut parameters, etc.
 - **Controls/**: `PlateView` (2D plate renderer with zoom/pan, supports temporary preview parts), `DrawingListBox`, `DrawControl`, `QuadrantSelect`.
-- **Actions/**: User interaction modes — `ActionSelect`, `ActionClone`, `ActionFillArea`, `ActionSelectArea`, `ActionZoomWindow`, `ActionSetSequence`.
+- **Actions/**: User interaction modes — `ActionSelect`, `ActionClone`, `ActionFillArea`, `ActionSelectArea`, `ActionZoomWindow`, `ActionSetSequence`, `ActionCutOff`.
 - **Post-processing**: `IPostProcessor` plugin interface loaded from DLLs in a `Posts/` directory at runtime.
 
 ## File Format
 
 Nest files (`.nest`, ZIP-based) use v2 JSON format:
-- `info.json` — nest metadata and plate defaults
-- `drawing-info.json` — drawing metadata (name, material, quantities, colors)
-- `plate-info.json` — plate metadata (size, material, spacing)
-- `program-NNN` — G-code text for each drawing's cut program
-- `plate-NNN` — G-code text encoding part placements (G00 for position, G65 for sub-program call with rotation)
+- `nest.json` — single JSON file containing all nest metadata: nest info (name, units, customer, dates, notes), plate defaults (size, thickness, quadrant, spacing, material, edge spacing), drawings array (id, name, color, quantity, priority, rotation constraints, material, source), and plates array (id, size, material, edge spacing, parts with drawingId/x/y/rotation, cutoffs with x/y/axis/startLimit/endLimit)
+- `programs/program-N` — G-code text for each drawing's cut program (N = drawing id)
+- `bestfits/bestfit-N` — JSON array of best-fit pair evaluation results per drawing, keyed by plate size/spacing (optional, only present if best-fit data was computed)
 
 ## Tool Preferences
 
@@ -99,12 +99,20 @@ Always use Roslyn Bridge MCP tools (`mcp__RoslynBridge__*`) as the primary metho
 
 - Always use `var` instead of explicit types (e.g., `var parts = new List<Part>();` not `List<Part> parts = new List<Part>();`).
 
+## Documentation Maintenance
+
+Always keep `README.md` and `CLAUDE.md` up to date when making changes that affect project structure, architecture, build instructions, dependencies, or key patterns. If you add a new project, change a namespace, modify the build process, or alter significant behavior, update both files as part of the same change.
+
+**Do not commit** design specs, implementation plans, or other temporary planning documents (`docs/superpowers/` etc.) to the repository. These are working documents only — keep them local and untracked.
+
 ## Key Patterns
 
 - OpenNest.Core uses multiple namespaces: `OpenNest` (root domain), `OpenNest.CNC`, `OpenNest.Geometry`, `OpenNest.Converters`, `OpenNest.Math`, `OpenNest.Collections`.
+- OpenNest.Engine uses sub-namespaces: `OpenNest.Engine.Fill` (fill algorithms), `OpenNest.Engine.Strategies` (pluggable strategy layer), `OpenNest.Engine.BestFit`, `OpenNest.Engine.Nfp` (NFP-based nesting, not yet integrated), `OpenNest.Engine.ML`, `OpenNest.Engine.RapidPlanning`, `OpenNest.Engine.Sequencing`.
 - `ObservableList<T>` provides ItemAdded/ItemRemoved/ItemChanged events used for automatic quantity tracking between plates and drawings.
 - Angles throughout the codebase are in **radians** (use `Angle.ToRadians()`/`Angle.ToDegrees()` for conversion).
 - `Tolerance.Epsilon` is used for floating-point comparisons across geometry operations.
 - Nesting uses async progress/cancellation: `IProgress<NestProgress>` and `CancellationToken` flow through the engine to the UI's `NestProgressForm`.
 - `Compactor` performs post-fill gravity compaction — after filling, parts are pushed toward a plate edge using directional distance calculations to close gaps between irregular shapes.
 - `FillScore` uses lexicographic comparison (count > utilization > compactness) to rank fill results consistently across all fill strategies.
+- **Cut-off materialization lifecycle**: `CutOff` objects live on `Plate.CutOffs`. Each generates a `Drawing` (with `IsCutOff = true`) whose `Program` contains trimmed line segments. `Plate.RegenerateCutOffs(settings)` removes old cut-off Parts, recomputes programs, and re-adds them to `Plate.Parts`. Regeneration triggers: cut-off add/remove/move, part drag complete, fill complete, plate transform. Cut-off Parts are excluded from quantity tracking, utilization, overlap detection, and nest file serialization (programs are regenerated from definitions on load).

OpenNest.Api/NestRequest.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using OpenNest.Geometry;
+
+namespace OpenNest.Api;
+
+public class NestRequest
+{
+    public IReadOnlyList<NestRequestPart> Parts { get; init; } = [];
+    public Size SheetSize { get; init; } = new(60, 120);
+    public string Material { get; init; } = "Steel, A1011 HR";
+    public double Thickness { get; init; } = 0.06;
+    public double Spacing { get; init; } = 0.1;
+    public NestStrategy Strategy { get; init; } = NestStrategy.Auto;
+    public CutParameters Cutting { get; init; } = CutParameters.Default;
+}

OpenNest.Api/NestRequestPart.cs

@@ -0,0 +1,9 @@
+namespace OpenNest.Api;
+
+public class NestRequestPart
+{
+    public string DxfPath { get; init; }
+    public int Quantity { get; init; } = 1;
+    public bool AllowRotation { get; init; } = true;
+    public int Priority { get; init; } = 0;
+}

OpenNest.Api/NestResponse.cs

@@ -0,0 +1,112 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Text.Json;
+using System.Threading.Tasks;
+using OpenNest.IO;
+
+namespace OpenNest.Api;
+
+public class NestResponse
+{
+    public int SheetCount { get; init; }
+    public double Utilization { get; init; }
+    public TimeSpan CutTime { get; init; }
+    public TimeSpan Elapsed { get; init; }
+    public Nest Nest { get; init; }
+    public NestRequest Request { get; init; }
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = true,
+        IncludeFields = true  // Required for OpenNest.Geometry.Size (public fields)
+    };
+
+    public async Task SaveAsync(string path)
+    {
+        using var fs = new FileStream(path, FileMode.Create);
+        using var zip = new ZipArchive(fs, ZipArchiveMode.Create);
+
+        // Write request.json
+        var requestEntry = zip.CreateEntry("request.json");
+        await using (var stream = requestEntry.Open())
+        {
+            await JsonSerializer.SerializeAsync(stream, Request, JsonOptions);
+        }
+
+        // Write response.json (metrics only)
+        var metrics = new
+        {
+            SheetCount,
+            Utilization,
+            CutTimeTicks = CutTime.Ticks,
+            ElapsedTicks = Elapsed.Ticks
+        };
+        var responseEntry = zip.CreateEntry("response.json");
+        await using (var stream = responseEntry.Open())
+        {
+            await JsonSerializer.SerializeAsync(stream, metrics, JsonOptions);
+        }
+
+        // Write embedded nest.nest via NestWriter → MemoryStream → ZIP entry
+        var nestEntry = zip.CreateEntry("nest.nest");
+        using var nestMs = new MemoryStream();
+        var writer = new NestWriter(Nest);
+        writer.Write(nestMs);
+        nestMs.Position = 0;
+        await using (var stream = nestEntry.Open())
+        {
+            await nestMs.CopyToAsync(stream);
+        }
+    }
+
+    public static async Task<NestResponse> LoadAsync(string path)
+    {
+        using var fs = new FileStream(path, FileMode.Open, FileAccess.Read);
+        using var zip = new ZipArchive(fs, ZipArchiveMode.Read);
+
+        // Read request.json
+        var requestEntry = zip.GetEntry("request.json")
+            ?? throw new InvalidOperationException("Missing request.json in .nestquote file");
+        NestRequest request;
+        await using (var stream = requestEntry.Open())
+        {
+            request = await JsonSerializer.DeserializeAsync<NestRequest>(stream, JsonOptions);
+        }
+
+        // Read response.json
+        var responseEntry = zip.GetEntry("response.json")
+            ?? throw new InvalidOperationException("Missing response.json in .nestquote file");
+        JsonElement metricsJson;
+        await using (var stream = responseEntry.Open())
+        {
+            metricsJson = await JsonSerializer.DeserializeAsync<JsonElement>(stream, JsonOptions);
+        }
+
+        // Read embedded nest.nest via NestReader(Stream)
+        var nestEntry = zip.GetEntry("nest.nest")
+            ?? throw new InvalidOperationException("Missing nest.nest in .nestquote file");
+        Nest nest;
+        using (var nestMs = new MemoryStream())
+        {
+            await using (var stream = nestEntry.Open())
+            {
+                await stream.CopyToAsync(nestMs);
+            }
+            nestMs.Position = 0;
+            var reader = new NestReader(nestMs);
+            nest = reader.Read();
+        }
+
+        return new NestResponse
+        {
+            SheetCount = metricsJson.GetProperty("sheetCount").GetInt32(),
+            Utilization = metricsJson.GetProperty("utilization").GetDouble(),
+            CutTime = TimeSpan.FromTicks(metricsJson.GetProperty("cutTimeTicks").GetInt64()),
+            Elapsed = TimeSpan.FromTicks(metricsJson.GetProperty("elapsedTicks").GetInt64()),
+            Nest = nest,
+            Request = request
+        };
+    }
+}

OpenNest.Api/NestRunner.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+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;
+
+public static class NestRunner
+{
+    public static Task<NestResponse> RunAsync(
+        NestRequest request,
+        IProgress<NestProgress> progress = null,
+        CancellationToken token = default)
+    {
+        if (request.Parts.Count == 0)
+            throw new ArgumentException("Request must contain at least one part.", nameof(request));
+
+        var sw = Stopwatch.StartNew();
+
+        // 1. Import DXFs → Drawings
+        var drawings = new List<Drawing>();
+        var importer = new DxfImporter();
+
+        foreach (var part in request.Parts)
+        {
+            if (!File.Exists(part.DxfPath))
+                throw new FileNotFoundException($"DXF file not found: {part.DxfPath}", part.DxfPath);
+
+            if (!importer.GetGeometry(part.DxfPath, out var geometry) || geometry.Count == 0)
+                throw new InvalidOperationException($"Failed to import DXF: {part.DxfPath}");
+
+            var pgm = ConvertGeometry.ToProgram(geometry);
+            var name = Path.GetFileNameWithoutExtension(part.DxfPath);
+            var drawing = new Drawing(name);
+            drawing.Program = pgm;
+            drawings.Add(drawing);
+        }
+
+        // 2. Build NestItems
+        var items = new List<NestItem>();
+        for (var i = 0; i < request.Parts.Count; i++)
+        {
+            var part = request.Parts[i];
+            items.Add(new NestItem
+            {
+                Drawing = drawings[i],
+                Quantity = part.Quantity,
+                Priority = part.Priority,
+                StepAngle = part.AllowRotation ? 0 : OpenNest.Math.Angle.TwoPI,
+            });
+        }
+
+        // 3. Multi-plate loop
+        var nest = new Nest();
+        var remaining = items.Select(item => item.Quantity).ToList();
+
+        while (remaining.Any(q => q > 0))
+        {
+            token.ThrowIfCancellationRequested();
+
+            var plate = new Plate(request.SheetSize)
+            {
+                Thickness = request.Thickness,
+                PartSpacing = request.Spacing,
+                Material = new Material(request.Material)
+            };
+
+            // Build items for this pass with remaining quantities
+            var passItems = new List<NestItem>();
+            for (var i = 0; i < items.Count; i++)
+            {
+                if (remaining[i] <= 0) continue;
+                passItems.Add(new NestItem
+                {
+                    Drawing = items[i].Drawing,
+                    Quantity = remaining[i],
+                    Priority = items[i].Priority,
+                    StepAngle = items[i].StepAngle,
+                });
+            }
+
+            // Run engine
+            var engine = NestEngineRegistry.Create(plate);
+            var parts = engine.Nest(passItems, progress, token);
+
+            if (parts.Count == 0)
+                break; // No progress — part doesn't fit on fresh sheet
+
+            // Add parts to plate and nest
+            foreach (var p in parts)
+                plate.Parts.Add(p);
+
+            nest.Plates.Add(plate);
+
+            // Deduct placed quantities
+            foreach (var p in parts)
+            {
+                var idx = drawings.IndexOf(p.BaseDrawing);
+                if (idx >= 0)
+                    remaining[idx]--;
+            }
+        }
+
+        // 4. Compute timing
+        var timingInfo = Timing.GetTimingInfo(nest);
+        var cutTime = Timing.CalculateTime(timingInfo, request.Cutting);
+
+        sw.Stop();
+
+        // 5. Build response
+        var response = new NestResponse
+        {
+            SheetCount = nest.Plates.Count,
+            Utilization = nest.Plates.Count > 0
+                ? nest.Plates.Average(p => p.Utilization())
+                : 0,
+            CutTime = cutTime,
+            Elapsed = sw.Elapsed,
+            Nest = nest,
+            Request = request
+        };
+
+        return Task.FromResult(response);
+    }
+}

OpenNest.Api/NestStrategy.cs

@@ -0,0 +1,3 @@
+namespace OpenNest.Api;
+
+public enum NestStrategy { Auto }

OpenNest.Api/OpenNest.Api.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <RootNamespace>OpenNest.Api</RootNamespace>
+    <AssemblyName>OpenNest.Api</AssemblyName>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />
+    <ProjectReference Include="..\OpenNest.Engine\OpenNest.Engine.csproj" />
+    <ProjectReference Include="..\OpenNest.IO\OpenNest.IO.csproj" />
+  </ItemGroup>
+</Project>

OpenNest.Console/Program.cs

@@ -1,13 +1,14 @@
+using OpenNest;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+using OpenNest.IO;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Threading;
-using OpenNest;
-using OpenNest.Converters;
-using OpenNest.Geometry;
-using OpenNest.IO;
 
 return NestConsole.Run(args);
 
@@ -20,6 +21,12 @@ static class NestConsole
         if (options == null)
             return 0; // --help was requested
 
+        if (options.ListPosts)
+        {
+            ListPostProcessors(options);
+            return 0;
+        }
+
         if (options.InputFiles.Count == 0)
         {
             PrintUsage();
@@ -68,6 +75,7 @@ static class NestConsole
 
         PrintResults(success, plate, elapsed);
         Save(nest, options);
+        PostProcess(nest, options);
 
         return options.CheckOverlaps && overlapCount > 0 ? 1 : 0;
     }
@@ -120,6 +128,18 @@ static class NestConsole
                 case "--engine" when i + 1 < args.Length:
                     NestEngineRegistry.ActiveEngineName = args[++i];
                     break;
+                case "--post" when i + 1 < args.Length:
+                    o.PostName = args[++i];
+                    break;
+                case "--post-output" when i + 1 < args.Length:
+                    o.PostOutput = args[++i];
+                    break;
+                case "--posts-dir" when i + 1 < args.Length:
+                    o.PostsDir = args[++i];
+                    break;
+                case "--list-posts":
+                    o.ListPosts = true;
+                    break;
                 case "--help":
                 case "-h":
                     PrintUsage();
@@ -191,7 +211,7 @@ static class NestConsole
         // DXF-only mode: create a fresh nest.
         if (dxfFiles.Count == 0)
         {
-            Console.Error.WriteLine("Error: no nest (.opnest) or DXF (.dxf) files specified");
+            Console.Error.WriteLine("Error: no nest (.nest) or DXF (.dxf) files specified");
             return null;
         }
 
@@ -382,17 +402,111 @@ static class NestConsole
         Console.WriteLine($"Saved: {outputFile}");
     }
 
+    static string ResolvePostsDir(Options options)
+    {
+        if (options.PostsDir != null)
+            return options.PostsDir;
+
+        var exePath = Assembly.GetEntryAssembly()?.Location
+                      ?? typeof(NestConsole).Assembly.Location;
+        return Path.Combine(Path.GetDirectoryName(exePath), "Posts");
+    }
+
+    static List<IPostProcessor> LoadPostProcessors(string postsDir)
+    {
+        var processors = new List<IPostProcessor>();
+
+        if (!Directory.Exists(postsDir))
+            return processors;
+
+        foreach (var file in Directory.GetFiles(postsDir, "*.dll"))
+        {
+            try
+            {
+                var assembly = Assembly.LoadFrom(file);
+
+                foreach (var type in assembly.GetTypes())
+                {
+                    if (!typeof(IPostProcessor).IsAssignableFrom(type) || type.IsInterface || type.IsAbstract)
+                        continue;
+
+                    if (Activator.CreateInstance(type) is IPostProcessor processor)
+                        processors.Add(processor);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"Warning: failed to load post processor from {Path.GetFileName(file)}: {ex.Message}");
+            }
+        }
+
+        return processors;
+    }
+
+    static void ListPostProcessors(Options options)
+    {
+        var postsDir = ResolvePostsDir(options);
+        var processors = LoadPostProcessors(postsDir);
+
+        if (processors.Count == 0)
+        {
+            Console.WriteLine($"No post processors found in: {postsDir}");
+            return;
+        }
+
+        Console.WriteLine($"Post processors ({postsDir}):");
+
+        foreach (var p in processors)
+            Console.WriteLine($"  {p.Name,-30} {p.Description}");
+    }
+
+    static void PostProcess(Nest nest, Options options)
+    {
+        if (options.PostName == null)
+            return;
+
+        var postsDir = ResolvePostsDir(options);
+        var processors = LoadPostProcessors(postsDir);
+        var post = processors.FirstOrDefault(p =>
+            p.Name.Equals(options.PostName, StringComparison.OrdinalIgnoreCase));
+
+        if (post == null)
+        {
+            Console.Error.WriteLine($"Error: post processor '{options.PostName}' not found");
+
+            if (processors.Count > 0)
+                Console.Error.WriteLine($"Available: {string.Join(", ", processors.Select(p => p.Name))}");
+            else
+                Console.Error.WriteLine($"No post processors found in: {postsDir}");
+
+            return;
+        }
+
+        var outputFile = options.PostOutput;
+
+        if (outputFile == null)
+        {
+            var firstInput = options.InputFiles[0];
+            outputFile = Path.Combine(
+                Path.GetDirectoryName(firstInput),
+                $"{Path.GetFileNameWithoutExtension(firstInput)}.cnc");
+        }
+
+        post.Post(nest, outputFile);
+        Console.WriteLine($"Post: {post.Name} -> {outputFile}");
+    }
+
     static void PrintUsage()
     {
         Console.Error.WriteLine("Usage: OpenNest.Console <input-files...> [options]");
         Console.Error.WriteLine();
         Console.Error.WriteLine("Arguments:");
-        Console.Error.WriteLine("  input-files            One or more .opnest nest files or .dxf drawing files");
+        Console.Error.WriteLine("  input-files            One or more .nest nest files or .dxf drawing files");
         Console.Error.WriteLine();
         Console.Error.WriteLine("Modes:");
-        Console.Error.WriteLine("  <nest.opnest>             Load nest and fill (existing behavior)");
+        Console.Error.WriteLine("  <nest.nest>             Load nest and fill (existing behavior)");
         Console.Error.WriteLine("  <part.dxf> --size WxL     Import DXF, create plate, and fill");
-        Console.Error.WriteLine("  <nest.opnest> <part.dxf>  Load nest and add imported DXF drawings");
+        Console.Error.WriteLine("  <nest.nest> <part.dxf>  Load nest and add imported DXF drawings");
         Console.Error.WriteLine();
         Console.Error.WriteLine("Options:");
         Console.Error.WriteLine("  --drawing <name>       Drawing name to fill with (default: first drawing)");
@@ -400,13 +514,17 @@ static class NestConsole
         Console.Error.WriteLine("  --quantity <n>          Max parts to place (default: 0 = unlimited)");
         Console.Error.WriteLine("  --spacing <value>      Override part spacing");
         Console.Error.WriteLine("  --size <WxL>           Override plate size (e.g. 60x120); required for DXF-only mode");
-        Console.Error.WriteLine("  --output <path>        Output nest file path (default: <input>-result.opnest)");
+        Console.Error.WriteLine("  --output <path>        Output nest file path (default: <input>-result.nest)");
         Console.Error.WriteLine("  --template <path>      Nest template for plate defaults (thickness, quadrant, material, spacing)");
         Console.Error.WriteLine("  --autonest             Use NFP-based mixed-part autonesting instead of linear fill");
         Console.Error.WriteLine("  --keep-parts           Don't clear existing parts before filling");
         Console.Error.WriteLine("  --check-overlaps       Run overlap detection after fill (exit code 1 if found)");
         Console.Error.WriteLine("  --no-save              Skip saving output file");
         Console.Error.WriteLine("  --no-log               Skip writing debug log file");
+        Console.Error.WriteLine("  --post <name>          Run a post processor after nesting");
+        Console.Error.WriteLine("  --post-output <path>   Output file for post processor (default: <input>.cnc)");
+        Console.Error.WriteLine("  --posts-dir <path>     Directory containing post processor DLLs (default: Posts/)");
+        Console.Error.WriteLine("  --list-posts           List available post processors and exit");
         Console.Error.WriteLine("  -h, --help             Show this help");
     }
 
@@ -425,5 +543,9 @@ static class NestConsole
         public bool KeepParts;
         public bool AutoNest;
         public string TemplateFile;
+        public string PostName;
+        public string PostOutput;
+        public string PostsDir;
+        public bool ListPosts;
     }
 }

OpenNest.Core/Align.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
-using OpenNest.Geometry;
+using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest
 {

OpenNest.Core/Bending/Bend.cs

@@ -0,0 +1,40 @@
+using OpenNest.Geometry;
+using OpenNest.Math;
+
+namespace OpenNest.Bending
+{
+    public class Bend
+    {
+        public Vector StartPoint { get; set; }
+        public Vector EndPoint { get; set; }
+        public BendDirection Direction { get; set; }
+        public double? Angle { get; set; }
+        public double? Radius { get; set; }
+        public string NoteText { get; set; }
+
+        [System.Text.Json.Serialization.JsonIgnore]
+        public Entity SourceEntity { get; set; }
+
+        public double Length => StartPoint.DistanceTo(EndPoint);
+
+        public double AngleRadians => Angle.HasValue
+            ? OpenNest.Math.Angle.ToRadians(Angle.Value)
+            : 0;
+
+        public Line ToLine() => new Line(StartPoint, EndPoint);
+
+        /// <summary>
+        /// Returns the angle of the bend line itself (not the bend angle).
+        /// Used for grain direction comparison.
+        /// </summary>
+        public double LineAngle => StartPoint.AngleTo(EndPoint);
+
+        public override string ToString()
+        {
+            var dir = Direction.ToString();
+            var angle = Angle?.ToString("0.##") ?? "?";
+            var radius = Radius?.ToString("0.###") ?? "?";
+            return $"{dir} {angle}° R{radius}";
+        }
+    }
+}

OpenNest.Core/Bending/BendDirection.cs

@@ -0,0 +1,9 @@
+namespace OpenNest.Bending
+{
+    public enum BendDirection
+    {
+        Unknown,
+        Up,
+        Down
+    }
+}

OpenNest.Core/CNC/CuttingStrategy/ContourCuttingStrategy.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

OpenNest.Core/CNC/CuttingStrategy/CuttingResult.cs

@@ -1,4 +1,3 @@
-using OpenNest.CNC;
 using OpenNest.Geometry;
 
 namespace OpenNest.CNC.CuttingStrategy

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

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

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

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

OpenNest.Core/CNC/CuttingStrategy/Tabs/BreakerTab.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

OpenNest.Core/CNC/CuttingStrategy/Tabs/MachineTab.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

OpenNest.Core/CNC/CuttingStrategy/Tabs/NormalTab.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

OpenNest.Core/CNC/CuttingStrategy/Tabs/Tab.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC.CuttingStrategy
 {

OpenNest.Core/CNC/Program.cs

@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
 using OpenNest.Converters;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.CNC
 {

OpenNest.Core/CNC/ProgramVariable.cs

@@ -0,0 +1,18 @@
+namespace OpenNest.CNC
+{
+    public sealed class ProgramVariable
+    {
+        public int Number { get; }
+        public string Name { get; }
+        public string Expression { get; set; }
+
+        public ProgramVariable(int number, string name, string expression = null)
+        {
+            Number = number;
+            Name = name;
+            Expression = expression;
+        }
+
+        public string Reference => $"#{Number}";
+    }
+}

OpenNest.Core/CNC/ProgramVariableManager.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OpenNest.CNC
+{
+    public sealed class ProgramVariableManager
+    {
+        private readonly Dictionary<int, ProgramVariable> _variables = new();
+
+        public ProgramVariable GetOrCreate(string name, int number, string expression = null)
+        {
+            if (_variables.TryGetValue(number, out var existing))
+                return existing;
+
+            var variable = new ProgramVariable(number, name, expression);
+            _variables[number] = variable;
+            return variable;
+        }
+
+        public List<string> EmitDeclarations()
+        {
+            return _variables.Values
+                .Where(v => v.Expression != null)
+                .OrderBy(v => v.Number)
+                .Select(v => $"{v.Reference}={v.Expression} ({FormatComment(v.Name)})")
+                .ToList();
+        }
+
+        private static string FormatComment(string name)
+        {
+            // "LeadInFeedrate" -> "LEAD IN FEEDRATE"
+            var sb = new StringBuilder();
+            foreach (var c in name)
+            {
+                if (char.IsUpper(c) && sb.Length > 0)
+                    sb.Append(' ');
+                sb.Append(char.ToUpper(c));
+            }
+            return sb.ToString();
+        }
+    }
+}

OpenNest.Core/Converters/ConvertGeometry.cs

@@ -1,7 +1,6 @@
-using System.Collections.Generic;
-using OpenNest;
-using OpenNest.CNC;
+using OpenNest.CNC;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Converters
 {

OpenNest.Core/Converters/ConvertProgram.cs

@@ -1,9 +1,7 @@
-using System;
-using System.Collections.Generic;
-using OpenNest;
-using OpenNest.CNC;
+using OpenNest.CNC;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.Converters
 {
@@ -61,9 +59,11 @@ namespace OpenNest.Converters
             if (mode == Mode.Incremental)
                 pt += curpos;
 
+            var layer = ConvertLayer(linearMove.Layer);
             var line = new Line(curpos, pt)
             {
-                Layer = ConvertLayer(linearMove.Layer)
+                Layer = layer,
+                Color = layer.Color
             };
             geometry.Add(line);
             curpos = pt;
@@ -78,7 +78,8 @@ namespace OpenNest.Converters
 
             var line = new Line(curpos, pt)
             {
-                Layer = SpecialLayers.Rapid
+                Layer = SpecialLayers.Rapid,
+                Color = SpecialLayers.Rapid.Color
             };
             geometry.Add(line);
             curpos = pt;
@@ -105,9 +106,9 @@ namespace OpenNest.Converters
             var layer = ConvertLayer(arcMove.Layer);
 
             if (startAngle.IsEqualTo(endAngle))
-                geometry.Add(new Circle(center, radius) { Layer = layer });
+                geometry.Add(new Circle(center, radius) { Layer = layer, Color = layer.Color });
             else
-                geometry.Add(new Arc(center, radius, startAngle, endAngle, arcMove.Rotation == RotationType.CW) { Layer = layer });
+                geometry.Add(new Arc(center, radius, startAngle, endAngle, arcMove.Rotation == RotationType.CW) { Layer = layer, Color = layer.Color });
 
             curpos = endpt;
         }

OpenNest.Core/CutOff.cs

@@ -0,0 +1,211 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest
+{
+    public enum CutOffAxis
+    {
+        Horizontal,
+        Vertical
+    }
+
+    public class CutOff
+    {
+        public Vector Position { get; set; }
+        public CutOffAxis Axis { get; set; }
+        public double? StartLimit { get; set; }
+        public double? EndLimit { get; set; }
+        public Drawing Drawing { get; private set; }
+
+        public CutOff(Vector position, CutOffAxis axis)
+        {
+            Position = position;
+            Axis = axis;
+            Drawing = new Drawing(GetName()) { IsCutOff = true };
+        }
+
+        public void Regenerate(Plate plate, CutOffSettings settings, Dictionary<Part, Entity> cache = null)
+        {
+            var segments = ComputeSegments(plate, settings, cache);
+            var program = BuildProgram(segments, settings);
+            Drawing.Program = program;
+        }
+
+        private string GetName()
+        {
+            var axisChar = Axis == CutOffAxis.Vertical ? "V" : "H";
+            var coord = Axis == CutOffAxis.Vertical ? Position.X : Position.Y;
+            return $"CutOff-{axisChar}-{coord:F2}";
+        }
+
+        private List<(double Start, double End)> ComputeSegments(Plate plate, CutOffSettings settings, Dictionary<Part, Entity> cache)
+        {
+            var bounds = plate.BoundingBox(includeParts: false);
+
+            double lineStart, lineEnd, cutPosition;
+
+            if (Axis == CutOffAxis.Vertical)
+            {
+                cutPosition = Position.X;
+                lineStart = StartLimit ?? bounds.Y;
+                lineEnd = EndLimit ?? (bounds.Y + bounds.Length + settings.Overtravel);
+            }
+            else
+            {
+                cutPosition = Position.Y;
+                lineStart = StartLimit ?? bounds.X;
+                lineEnd = EndLimit ?? (bounds.X + bounds.Width + settings.Overtravel);
+            }
+
+            var exclusions = new List<(double Start, double End)>();
+
+            foreach (var part in plate.Parts)
+            {
+                if (part.BaseDrawing.IsCutOff)
+                    continue;
+
+                Entity perimeter = null;
+                cache?.TryGetValue(part, out perimeter);
+                var partExclusions = GetPartExclusions(part, perimeter, cutPosition, lineStart, lineEnd, settings.PartClearance);
+                exclusions.AddRange(partExclusions);
+            }
+
+            exclusions.Sort((a, b) => a.Start.CompareTo(b.Start));
+            var merged = new List<(double Start, double End)>();
+            foreach (var ex in exclusions)
+            {
+                if (merged.Count > 0 && ex.Start <= merged[^1].End)
+                    merged[^1] = (merged[^1].Start, System.Math.Max(merged[^1].End, ex.End));
+                else
+                    merged.Add(ex);
+            }
+
+            var segments = new List<(double Start, double End)>();
+            var current = lineStart;
+
+            foreach (var ex in merged)
+            {
+                var clampedStart = System.Math.Max(ex.Start, lineStart);
+                var clampedEnd = System.Math.Min(ex.End, lineEnd);
+
+                if (clampedStart > current)
+                    segments.Add((current, clampedStart));
+
+                current = System.Math.Max(current, clampedEnd);
+            }
+
+            if (current < lineEnd)
+                segments.Add((current, lineEnd));
+
+            segments = segments.Where(s => (s.End - s.Start) >= settings.MinSegmentLength).ToList();
+
+            return segments;
+        }
+
+        private static readonly List<(double Start, double End)> EmptyExclusions = new();
+
+        private List<(double Start, double End)> GetPartExclusions(
+            Part part, Entity perimeter, double cutPosition, double lineStart, double lineEnd, double clearance)
+        {
+            var bb = part.BoundingBox;
+            var (partMin, partMax) = AxisBounds(bb, clearance);
+            var (partStart, partEnd) = CrossAxisBounds(bb, clearance);
+
+            if (cutPosition < partMin || cutPosition > partMax)
+                return EmptyExclusions;
+
+            if (perimeter != null)
+            {
+                var perimeterExclusions = IntersectPerimeter(perimeter, cutPosition, lineStart, lineEnd, clearance);
+                if (perimeterExclusions != null)
+                    return perimeterExclusions;
+            }
+
+            return new List<(double Start, double End)> { (partStart, partEnd) };
+        }
+
+        private List<(double Start, double End)> IntersectPerimeter(
+            Entity perimeter, double cutPosition, double lineStart, double lineEnd, double clearance)
+        {
+            var target = OffsetOutward(perimeter, clearance) ?? perimeter;
+            var usedOffset = target != perimeter;
+            var cutLine = new Line(MakePoint(cutPosition, lineStart), MakePoint(cutPosition, lineEnd));
+
+            if (!target.Intersects(cutLine, out var pts) || pts.Count < 2)
+                return null;
+
+            var coords = pts
+                .Select(pt => Axis == CutOffAxis.Vertical ? pt.Y : pt.X)
+                .OrderBy(c => c)
+                .ToList();
+
+            if (coords.Count % 2 != 0)
+                return null;
+
+            var padding = usedOffset ? 0 : clearance;
+            var result = new List<(double Start, double End)>();
+            for (var i = 0; i < coords.Count; i += 2)
+                result.Add((coords[i] - padding, coords[i + 1] + padding));
+
+            return result;
+        }
+
+        private static Entity OffsetOutward(Entity perimeter, double clearance)
+        {
+            if (clearance <= 0)
+                return null;
+
+            try
+            {
+                var offset = perimeter.OffsetEntity(clearance, OffsetSide.Left);
+                offset?.UpdateBounds();
+                return offset;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private Vector MakePoint(double cutCoord, double lineCoord) =>
+            Axis == CutOffAxis.Vertical
+                ? new Vector(cutCoord, lineCoord)
+                : new Vector(lineCoord, cutCoord);
+
+        private (double Min, double Max) AxisBounds(Box bb, double clearance) =>
+            Axis == CutOffAxis.Vertical
+                ? (bb.X - clearance, bb.X + bb.Width + clearance)
+                : (bb.Y - clearance, bb.Y + bb.Length + clearance);
+
+        private (double Start, double End) CrossAxisBounds(Box bb, double clearance) =>
+            Axis == CutOffAxis.Vertical
+                ? (bb.Y - clearance, bb.Y + bb.Length + clearance)
+                : (bb.X - clearance, bb.X + bb.Width + clearance);
+
+        private Program BuildProgram(List<(double Start, double End)> segments, CutOffSettings settings)
+        {
+            var program = new Program();
+
+            if (segments.Count == 0)
+                return program;
+
+            var toward = settings.CutDirection == CutDirection.TowardOrigin;
+            segments = toward
+                ? segments.OrderByDescending(s => s.Start).ToList()
+                : segments.OrderBy(s => s.Start).ToList();
+
+            var cutPos = Axis == CutOffAxis.Vertical ? Position.X : Position.Y;
+
+            foreach (var seg in segments)
+            {
+                var (from, to) = toward ? (seg.End, seg.Start) : (seg.Start, seg.End);
+                program.Codes.Add(new RapidMove(MakePoint(cutPos, from)));
+                program.Codes.Add(new LinearMove(MakePoint(cutPos, to)));
+            }
+
+            return program;
+        }
+    }
+}

OpenNest.Core/CutOffSettings.cs

@@ -0,0 +1,16 @@
+namespace OpenNest
+{
+    public enum CutDirection
+    {
+        TowardOrigin,
+        AwayFromOrigin
+    }
+
+    public class CutOffSettings
+    {
+        public double PartClearance { get; set; } = 0.02;
+        public double Overtravel { get; set; }
+        public double MinSegmentLength { get; set; } = 0.05;
+        public CutDirection CutDirection { get; set; } = CutDirection.AwayFromOrigin;
+    }
+}

OpenNest.Core/CutParameters.cs

@@ -1,15 +1,21 @@
-using System;
+using System;
 
-namespace OpenNest
+namespace OpenNest.Api;
+
+public class CutParameters
 {
-    public class CutParameters
+    public double Feedrate { get; set; }
+    public double RapidTravelRate { get; set; }
+    public TimeSpan PierceTime { get; set; }
+    public double LeadInLength { get; set; }
+    public string PostProcessor { get; set; }
+    public Units Units { get; set; }
+
+    public static CutParameters Default => new()
     {
-        public double Feedrate { get; set; }
-
-        public double RapidTravelRate { get; set; }
-
-        public TimeSpan PierceTime { get; set; }
-
-        public Units Units { get; set; }
-    }
+        Feedrate = 100,
+        RapidTravelRate = 300,
+        PierceTime = TimeSpan.FromSeconds(0.5),
+        Units = OpenNest.Units.Inches
+    };
 }

OpenNest.Core/Drawing.cs

@@ -1,9 +1,11 @@
-using System.Drawing;
-using System.Linq;
-using System.Threading;
+using OpenNest.Bending;
 using OpenNest.CNC;
 using OpenNest.Converters;
 using OpenNest.Geometry;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Threading;
 
 namespace OpenNest
 {
@@ -56,10 +58,14 @@ namespace OpenNest
 
         public Color Color { get; set; }
 
+        public bool IsCutOff { get; set; }
+
         public NestConstraints Constraints { get; set; }
 
         public SourceInfo Source { get; set; }
 
+        public List<Bend> Bends { get; set; } = new List<Bend>();
+
         public double Area { get; protected set; }
 
         public void UpdateArea()

OpenNest.Core/DwgQty.cs

@@ -8,10 +8,10 @@
 
         public int Remaining
         {
-            get 
+            get
             {
                 var x = Required - Nested;
-                return x < 0 ? 0: x; 
+                return x < 0 ? 0 : x;
             }
         }
     }

OpenNest.Core/Geometry/Arc.cs

@@ -1,6 +1,6 @@
-using System;
+using OpenNest.Math;
+using System;
 using System.Collections.Generic;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {

OpenNest.Core/Geometry/Box.cs

@@ -74,6 +74,16 @@ namespace OpenNest.Geometry
             Location += voffset;
         }
 
+        public Box Translate(double x, double y)
+        {
+            return new Box(X + x, Y + y, Width, Length);
+        }
+
+        public Box Translate(Vector offset)
+        {
+            return new Box(X + offset.X, Y + offset.Y, Width, Length);
+        }
+
         public double Left
         {
             get { return X; }

OpenNest.Core/Geometry/Circle.cs

@@ -1,6 +1,5 @@
-using System;
+using OpenNest.Math;
 using System.Collections.Generic;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {

OpenNest.Core/Geometry/Entity.cs

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
+using OpenNest.Math;
+using System.Collections.Generic;
 using System.Drawing;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {
@@ -247,7 +247,7 @@ namespace OpenNest.Geometry
 
     public static class EntityExtensions
     {
-        public static BoundingRectangleResult FindBestRotation(this List<Entity> entities, double startAngle = 0, double endAngle = Angle.TwoPI)
+        public static List<Vector> CollectPoints(this IEnumerable<Entity> entities)
         {
             var points = new List<Vector>();
 
@@ -286,17 +286,35 @@ namespace OpenNest.Geometry
 
                     case EntityType.Shape:
                         var shape = (Shape)entity;
-                        var subResult = shape.Entities.FindBestRotation(startAngle, endAngle);
-                        return subResult;
+                        points.AddRange(shape.Entities.CollectPoints());
+                        break;
                 }
             }
 
+            return points;
+        }
+
+        public static BoundingRectangleResult FindBestRotation(this List<Entity> entities, double startAngle = 0, double endAngle = Angle.TwoPI)
+        {
+            // Check for Shape entity first (recursive case returns early)
+            foreach (var entity in entities)
+            {
+                if (entity.Type == EntityType.Shape)
+                {
+                    var shape = (Shape)entity;
+                    var subResult = shape.Entities.FindBestRotation(startAngle, endAngle);
+                    return subResult;
+                }
+            }
+
+            var points = entities.CollectPoints();
+
             if (points.Count == 0)
                 return new BoundingRectangleResult(startAngle, 0, 0);
 
             var hull = ConvexHull.Compute(points);
 
-            bool constrained = !startAngle.IsEqualTo(0) || !endAngle.IsEqualTo(Angle.TwoPI);
+            var constrained = !startAngle.IsEqualTo(0) || !endAngle.IsEqualTo(Angle.TwoPI);
 
             return constrained
                 ? RotatingCalipers.MinimumBoundingRectangle(hull, startAngle, endAngle)

OpenNest.Core/Geometry/GeometryOptimizer.cs

@@ -1,7 +1,7 @@
+using OpenNest.Math;
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {
@@ -133,17 +133,30 @@ namespace OpenNest.Geometry
             if (!arc1.Radius.IsEqualTo(arc2.Radius))
                 return false;
 
-            if (arc1.StartAngle > arc1.EndAngle)
-                arc1.StartAngle -= Angle.TwoPI;
+            var start1 = arc1.StartAngle;
+            var end1 = arc1.EndAngle;
+            var start2 = arc2.StartAngle;
+            var end2 = arc2.EndAngle;
 
-            if (arc2.StartAngle > arc2.EndAngle)
-                arc2.StartAngle -= Angle.TwoPI;
+            if (start1 > end1)
+                start1 -= Angle.TwoPI;
 
-            if (arc1.EndAngle < arc2.StartAngle || arc1.StartAngle > arc2.EndAngle)
+            if (start2 > end2)
+                start2 -= Angle.TwoPI;
+
+            // Check that arcs are adjacent (endpoints touch), not overlapping
+            var touch1 = end1.IsEqualTo(start2) || (end1 + Angle.TwoPI).IsEqualTo(start2);
+            var touch2 = end2.IsEqualTo(start1) || (end2 + Angle.TwoPI).IsEqualTo(start1);
+            if (!touch1 && !touch2)
                 return false;
 
-            var startAngle = arc1.StartAngle < arc2.StartAngle ? arc1.StartAngle : arc2.StartAngle;
-            var endAngle = arc1.EndAngle > arc2.EndAngle ? arc1.EndAngle : arc2.EndAngle;
+            var startAngle = start1 < start2 ? start1 : start2;
+            var endAngle = end1 > end2 ? end1 : end2;
+
+            // Don't merge if the result would be a full circle (start == end)
+            var sweep = endAngle - startAngle;
+            if (sweep >= Angle.TwoPI - Tolerance.Epsilon)
+                return false;
 
             if (startAngle < 0) startAngle += Angle.TwoPI;
             if (endAngle < 0) endAngle += Angle.TwoPI;

OpenNest.Core/Geometry/InnerFitPolygon.cs

@@ -52,6 +52,7 @@ namespace OpenNest.Geometry
             result.Vertices.Add(new Vector(ifpRight, ifpTop));
             result.Vertices.Add(new Vector(ifpLeft, ifpTop));
             result.Close();
+            result.UpdateBounds();
 
             return result;
         }
@@ -62,36 +63,20 @@ namespace OpenNest.Geometry
         /// Returns the polygon representing valid placement positions, or an empty
         /// polygon if no valid position exists.
         /// </summary>
-        public static Polygon ComputeFeasibleRegion(Polygon ifp, Polygon[] nfps)
+        public static Polygon ComputeFeasibleRegion(Polygon ifp, PathsD nfpPaths)
         {
             if (ifp.Vertices.Count < 3)
                 return new Polygon();
 
-            if (nfps == null || nfps.Length == 0)
+            if (nfpPaths == null || nfpPaths.Count == 0)
                 return ifp;
 
             var ifpPath = NoFitPolygon.ToClipperPath(ifp);
             var ifpPaths = new PathsD { ifpPath };
 
-            // Union all NFPs.
-            var nfpPaths = new PathsD();
-
-            foreach (var nfp in nfps)
-            {
-                if (nfp.Vertices.Count >= 3)
-                {
-                    var path = NoFitPolygon.ToClipperPath(nfp);
-                    nfpPaths.Add(path);
-                }
-            }
-
-            if (nfpPaths.Count == 0)
-                return ifp;
-
-            var nfpUnion = Clipper.Union(nfpPaths, FillRule.NonZero);
-
-            // Subtract the NFP union from the IFP.
-            var feasible = Clipper.Difference(ifpPaths, nfpUnion, FillRule.NonZero);
+            // Subtract the NFPs from the IFP.
+            // Clipper2 handles the implicit union of the clip paths.
+            var feasible = Clipper.Difference(ifpPaths, nfpPaths, FillRule.NonZero);
 
             if (feasible.Count == 0)
                 return new Polygon();
@@ -118,6 +103,25 @@ namespace OpenNest.Geometry
             return bestPath != null ? NoFitPolygon.FromClipperPath(bestPath) : new Polygon();
         }
 
+        /// <summary>
+        /// Computes the feasible region for placing a part given already-placed parts.
+        /// (Legacy overload for backward compatibility).
+        /// </summary>
+        public static Polygon ComputeFeasibleRegion(Polygon ifp, Polygon[] nfps)
+        {
+            if (nfps == null || nfps.Length == 0)
+                return ifp;
+
+            var nfpPaths = new PathsD(nfps.Length);
+            foreach (var nfp in nfps)
+            {
+                if (nfp.Vertices.Count >= 3)
+                    nfpPaths.Add(NoFitPolygon.ToClipperPath(nfp));
+            }
+
+            return ComputeFeasibleRegion(ifp, nfpPaths);
+        }
+
         /// <summary>
         /// Finds the bottom-left-most point on a polygon boundary.
         /// "Bottom-left" means: minimize Y first, then minimize X.

OpenNest.Core/Geometry/Intersect.cs

@@ -1,6 +1,6 @@
+using OpenNest.Math;
 using System.Collections.Generic;
 using System.Linq;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {
@@ -219,6 +219,14 @@ namespace OpenNest.Geometry
         }
 
         internal static bool Intersects(Line line1, Line line2, out Vector pt)
+        {
+            if (!IntersectsUnbounded(line1, line2, out pt))
+                return false;
+
+            return line1.BoundingBox.Contains(pt) && line2.BoundingBox.Contains(pt);
+        }
+
+        internal static bool IntersectsUnbounded(Line line1, Line line2, out Vector pt)
         {
             var a1 = line1.EndPoint.Y - line1.StartPoint.Y;
             var b1 = line1.StartPoint.X - line1.EndPoint.X;
@@ -240,7 +248,7 @@ namespace OpenNest.Geometry
             var y = (a1 * c2 - a2 * c1) / d;
 
             pt = new Vector(x, y);
-            return line1.BoundingBox.Contains(pt) && line2.BoundingBox.Contains(pt);
+            return true;
         }
 
         internal static bool Intersects(Line line, Shape shape, out List<Vector> pts)
@@ -249,9 +257,8 @@ namespace OpenNest.Geometry
 
             foreach (var geo in shape.Entities)
             {
-                List<Vector> pts3;
-                geo.Intersects(line, out pts3);
-                pts.AddRange(pts3);
+                if (geo.Intersects(line, out var pts3))
+                    pts.AddRange(pts3);
             }
 
             return pts.Count > 0;

OpenNest.Core/Geometry/Line.cs

@@ -1,6 +1,6 @@
-using System;
+using OpenNest.Math;
+using System;
 using System.Collections.Generic;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {

OpenNest.Core/Geometry/NoFitPolygon.cs

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
-using System.Linq;
 using Clipper2Lib;
+using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.Geometry
 {
@@ -23,8 +23,20 @@ namespace OpenNest.Geometry
             return MinkowskiSum(stationary, reflected);
         }
 
+        /// <summary>
+        /// Optimized version of Compute for polygons known to be convex.
+        /// Bypasses expensive triangulation and Clipper unions.
+        /// </summary>
+        public static Polygon ComputeConvex(Polygon stationary, Polygon orbiting)
+        {
+            var reflected = Reflect(orbiting);
+            return ConvexMinkowskiSum(stationary, reflected);
+        }
+
         /// <summary>
         /// Reflects a polygon through the origin (negates all vertex coordinates).
+        /// Point reflection (negating both axes) is equivalent to 180° rotation,
+        /// which preserves winding order. No reversal needed.
         /// </summary>
         private static Polygon Reflect(Polygon polygon)
         {
@@ -33,8 +45,6 @@ namespace OpenNest.Geometry
             foreach (var v in polygon.Vertices)
                 result.Vertices.Add(new Vector(-v.X, -v.Y));
 
-            // Reflecting reverses winding order — reverse to maintain CCW.
-            result.Vertices.Reverse();
             return result;
         }
 
@@ -79,19 +89,24 @@ namespace OpenNest.Geometry
         /// edge vectors sorted by angle. O(n+m) where n and m are vertex counts.
         /// Both polygons must have CCW winding.
         /// </summary>
-        internal static Polygon ConvexMinkowskiSum(Polygon a, Polygon b)
+        public static Polygon ConvexMinkowskiSum(Polygon a, Polygon b)
         {
             var edgesA = GetEdgeVectors(a);
             var edgesB = GetEdgeVectors(b);
 
-            // Find bottom-most (then left-most) vertex for each polygon as starting point.
+            // Find indices of bottom-left vertices for both.
             var startA = FindBottomLeft(a);
             var startB = FindBottomLeft(b);
 
             var result = new Polygon();
+            
+            // The starting point of the Minkowski sum A + B is the sum of the 
+            // starting points of A and B. For NFP = A + (-B), this is 
+            // startA + startReflectedB.
             var current = new Vector(
                 a.Vertices[startA].X + b.Vertices[startB].X,
                 a.Vertices[startA].Y + b.Vertices[startB].Y);
+            
             result.Vertices.Add(current);
 
             var ia = 0;
@@ -99,7 +114,6 @@ namespace OpenNest.Geometry
             var na = edgesA.Count;
             var nb = edgesB.Count;
 
-            // Reorder edges to start from the bottom-left vertex.
             var orderedA = ReorderEdges(edgesA, startA);
             var orderedB = ReorderEdges(edgesB, startB);
 
@@ -118,7 +132,10 @@ namespace OpenNest.Geometry
                 else
                 {
                     var angleA = System.Math.Atan2(orderedA[ia].Y, orderedA[ia].X);
+                    if (angleA < 0) angleA += Angle.TwoPI;
+
                     var angleB = System.Math.Atan2(orderedB[ib].Y, orderedB[ib].X);
+                    if (angleB < 0) angleB += Angle.TwoPI;
 
                     if (angleA < angleB)
                     {
@@ -130,7 +147,6 @@ namespace OpenNest.Geometry
                     }
                     else
                     {
-                        // Same angle — merge both edges.
                         edge = new Vector(
                             orderedA[ia].X + orderedB[ib].X,
                             orderedA[ia].Y + orderedB[ib].Y);
@@ -144,6 +160,7 @@ namespace OpenNest.Geometry
             }
 
             result.Close();
+            result.UpdateBounds();
             return result;
         }
 
@@ -251,9 +268,9 @@ namespace OpenNest.Geometry
         }
 
         /// <summary>
-        /// Converts an OpenNest Polygon to a Clipper2 PathD.
+        /// Converts an OpenNest Polygon to a Clipper2 PathD, with an optional offset.
         /// </summary>
-        internal static PathD ToClipperPath(Polygon polygon)
+        public static PathD ToClipperPath(Polygon polygon, Vector offset = default)
         {
             var path = new PathD();
             var verts = polygon.Vertices;
@@ -264,7 +281,7 @@ namespace OpenNest.Geometry
                 n--;
 
             for (var i = 0; i < n; i++)
-                path.Add(new PointD(verts[i].X, verts[i].Y));
+                path.Add(new PointD(verts[i].X + offset.X, verts[i].Y + offset.Y));
 
             return path;
         }
@@ -272,7 +289,7 @@ namespace OpenNest.Geometry
         /// <summary>
         /// Converts a Clipper2 PathD to an OpenNest Polygon.
         /// </summary>
-        internal static Polygon FromClipperPath(PathD path)
+        public static Polygon FromClipperPath(PathD path)
         {
             var polygon = new Polygon();
 
@@ -280,6 +297,7 @@ namespace OpenNest.Geometry
                 polygon.Vertices.Add(new Vector(pt.x, pt.y));
 
             polygon.Close();
+            polygon.UpdateBounds();
             return polygon;
         }
     }

OpenNest.Core/Geometry/PolyLabel.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 
 namespace OpenNest.Geometry

OpenNest.Core/Geometry/Polygon.cs

@@ -1,7 +1,7 @@
-using System;
+using OpenNest.Math;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {
@@ -317,12 +317,68 @@ namespace OpenNest.Geometry
 
         public override Entity OffsetEntity(double distance, OffsetSide side)
         {
-            throw new NotImplementedException();
+            if (Vertices.Count < 3)
+                return null;
+
+            var isClosed = IsClosed();
+            var count = isClosed ? Vertices.Count - 1 : Vertices.Count;
+            if (count < 3)
+                return null;
+
+            var ccw = CalculateArea() > 0;
+            var outward = ccw ? OffsetSide.Left : OffsetSide.Right;
+            var sign = side == outward ? 1.0 : -1.0;
+            var d = distance * sign;
+
+            var normals = new Vector[count];
+            for (var i = 0; i < count; i++)
+            {
+                var next = (i + 1) % count;
+                var dx = Vertices[next].X - Vertices[i].X;
+                var dy = Vertices[next].Y - Vertices[i].Y;
+                var len = System.Math.Sqrt(dx * dx + dy * dy);
+                if (len < Tolerance.Epsilon)
+                    return null;
+                normals[i] = new Vector(-dy / len * d, dx / len * d);
+            }
+
+            var result = new Polygon();
+            for (var i = 0; i < count; i++)
+            {
+                var prev = (i - 1 + count) % count;
+
+                var a1 = new Vector(Vertices[prev].X + normals[prev].X, Vertices[prev].Y + normals[prev].Y);
+                var a2 = new Vector(Vertices[i].X + normals[prev].X, Vertices[i].Y + normals[prev].Y);
+                var b1 = new Vector(Vertices[i].X + normals[i].X, Vertices[i].Y + normals[i].Y);
+                var b2 = new Vector(Vertices[(i + 1) % count].X + normals[i].X, Vertices[(i + 1) % count].Y + normals[i].Y);
+
+                var edgeA = new Line(a1, a2);
+                var edgeB = new Line(b1, b2);
+
+                if (edgeA.Intersects(edgeB, out var pt) && pt.IsValid())
+                    result.Vertices.Add(pt);
+                else
+                    result.Vertices.Add(new Vector(Vertices[i].X + normals[i].X, Vertices[i].Y + normals[i].Y));
+            }
+
+            result.Close();
+            result.RemoveSelfIntersections();
+            result.UpdateBounds();
+            return result;
         }
 
         public override Entity OffsetEntity(double distance, Vector pt)
         {
-            throw new NotImplementedException();
+            var left = OffsetEntity(distance, OffsetSide.Left);
+            var right = OffsetEntity(distance, OffsetSide.Right);
+
+            if (left == null) return right;
+            if (right == null) return left;
+
+            var distLeft = left.ClosestPointTo(pt).DistanceTo(pt);
+            var distRight = right.ClosestPointTo(pt).DistanceTo(pt);
+
+            return distLeft > distRight ? left : right;
         }
 
         /// <summary>

OpenNest.Core/Geometry/RotatingCalipers.cs

@@ -1,6 +1,5 @@
-using System;
-using System.Collections.Generic;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.Geometry
 {

OpenNest.Core/Geometry/Shape.cs

@@ -534,7 +534,7 @@ namespace OpenNest.Geometry
         {
             Vector intersection;
 
-            if (Intersect.Intersects(offsetLine, lastOffsetLine, out intersection))
+            if (Intersect.IntersectsUnbounded(offsetLine, lastOffsetLine, out intersection))
             {
                 offsetLine.StartPoint = intersection;
                 lastOffsetLine.EndPoint = intersection;
@@ -558,6 +558,46 @@ namespace OpenNest.Geometry
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Offsets the shape outward by the given distance, detecting winding direction
+        /// to choose the correct offset side. Falls back to the opposite side if the
+        /// bounding box shrinks (indicating the offset went inward).
+        /// </summary>
+        public Shape OffsetOutward(double distance)
+        {
+            var poly = ToPolygon();
+            var side = poly.Vertices.Count >= 3 && poly.RotationDirection() == RotationType.CW
+                ? OffsetSide.Left
+                : OffsetSide.Right;
+
+            var result = OffsetEntity(distance, side) as Shape;
+
+            if (result == null)
+                return null;
+
+            UpdateBounds();
+            var originalBB = BoundingBox;
+            result.UpdateBounds();
+            var offsetBB = result.BoundingBox;
+
+            if (offsetBB.Width < originalBB.Width || offsetBB.Length < originalBB.Length)
+            {
+                Trace.TraceWarning(
+                    "Shape.OffsetOutward: offset shrank bounding box " +
+                    $"(original={originalBB.Width:F3}x{originalBB.Length:F3}, " +
+                    $"offset={offsetBB.Width:F3}x{offsetBB.Length:F3}). " +
+                    "Retrying with opposite side.");
+
+                var opposite = side == OffsetSide.Left ? OffsetSide.Right : OffsetSide.Left;
+                var retry = OffsetEntity(distance, opposite) as Shape;
+
+                if (retry != null)
+                    result = retry;
+            }
+
+            return result;
+        }
+
         /// <summary>
         /// Gets the closest point on the shape to the given point.
         /// </summary>

OpenNest.Core/Geometry/ShapeBuilder.cs

@@ -1,6 +1,6 @@
+using OpenNest.Math;
 using System.Collections.Generic;
 using System.Diagnostics;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {

OpenNest.Core/Geometry/ShapeProfile.cs

@@ -21,9 +21,12 @@ namespace OpenNest.Geometry
             Perimeter = shapes[0];
             Cutouts = new List<Shape>();
 
-            for (int i = 1; i < shapes.Count; i++)
+            for (var i = 1; i < shapes.Count; i++)
             {
-                if (shapes[i].Left < Perimeter.Left)
+                var bb = shapes[i].BoundingBox;
+                var perimBB = Perimeter.BoundingBox;
+
+                if (bb.Width * bb.Length > perimBB.Width * perimBB.Length)
                 {
                     Cutouts.Add(Perimeter);
                     Perimeter = shapes[i];

OpenNest.Core/Geometry/Size.cs

@@ -43,7 +43,7 @@ namespace OpenNest.Geometry
         }
 
         public override string ToString() => $"{Width} x {Length}";
-        
+
         public string ToString(int decimalPlaces) => $"{System.Math.Round(Width, decimalPlaces)} x {System.Math.Round(Length, decimalPlaces)}";
     }
 }

OpenNest.Core/Geometry/SpatialQuery.cs

@@ -1,7 +1,6 @@
-using System;
+using OpenNest.Math;
 using System.Collections.Generic;
 using System.Linq;
-using OpenNest.Math;
 
 namespace OpenNest.Geometry
 {
@@ -30,47 +29,81 @@ namespace OpenNest.Geometry
             {
                 case PushDirection.Left:
                 case PushDirection.Right:
-                {
-                    var dy = p2y - p1y;
-                    if (System.Math.Abs(dy) < Tolerance.Epsilon)
+                    {
+                        var dy = p2y - p1y;
+                        if (System.Math.Abs(dy) < Tolerance.Epsilon)
+                            return double.MaxValue;
+
+                        var t = (vy - p1y) / dy;
+                        if (t < -Tolerance.Epsilon || t > 1.0 + Tolerance.Epsilon)
+                            return double.MaxValue;
+
+                        var ix = p1x + t * (p2x - p1x);
+                        var dist = direction == PushDirection.Left ? vx - ix : ix - vx;
+
+                        if (dist > Tolerance.Epsilon) return dist;
+                        if (dist >= -Tolerance.Epsilon) return 0;
                         return double.MaxValue;
-
-                    var t = (vy - p1y) / dy;
-                    if (t < -Tolerance.Epsilon || t > 1.0 + Tolerance.Epsilon)
-                        return double.MaxValue;
-
-                    var ix = p1x + t * (p2x - p1x);
-                    var dist = direction == PushDirection.Left ? vx - ix : ix - vx;
-
-                    if (dist > Tolerance.Epsilon) return dist;
-                    if (dist >= -Tolerance.Epsilon) return 0;
-                    return double.MaxValue;
-                }
+                    }
 
                 case PushDirection.Down:
                 case PushDirection.Up:
-                {
-                    var dx = p2x - p1x;
-                    if (System.Math.Abs(dx) < Tolerance.Epsilon)
+                    {
+                        var dx = p2x - p1x;
+                        if (System.Math.Abs(dx) < Tolerance.Epsilon)
+                            return double.MaxValue;
+
+                        var t = (vx - p1x) / dx;
+                        if (t < -Tolerance.Epsilon || t > 1.0 + Tolerance.Epsilon)
+                            return double.MaxValue;
+
+                        var iy = p1y + t * (p2y - p1y);
+                        var dist = direction == PushDirection.Down ? vy - iy : iy - vy;
+
+                        if (dist > Tolerance.Epsilon) return dist;
+                        if (dist >= -Tolerance.Epsilon) return 0;
                         return double.MaxValue;
-
-                    var t = (vx - p1x) / dx;
-                    if (t < -Tolerance.Epsilon || t > 1.0 + Tolerance.Epsilon)
-                        return double.MaxValue;
-
-                    var iy = p1y + t * (p2y - p1y);
-                    var dist = direction == PushDirection.Down ? vy - iy : iy - vy;
-
-                    if (dist > Tolerance.Epsilon) return dist;
-                    if (dist >= -Tolerance.Epsilon) return 0;
-                    return double.MaxValue;
-                }
+                    }
 
                 default:
                     return double.MaxValue;
             }
         }
 
+        /// <summary>
+        /// Generalized ray-edge distance along an arbitrary unit direction vector.
+        /// Returns double.MaxValue if the ray does not hit the segment.
+        /// </summary>
+        [System.Runtime.CompilerServices.MethodImpl(
+            System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static double RayEdgeDistance(
+            double vx, double vy,
+            double p1x, double p1y, double p2x, double p2y,
+            double dirX, double dirY)
+        {
+            var ex = p2x - p1x;
+            var ey = p2y - p1y;
+
+            var det = ex * dirY - ey * dirX;
+            if (System.Math.Abs(det) < Tolerance.Epsilon)
+                return double.MaxValue;
+
+            var dvx = p1x - vx;
+            var dvy = p1y - vy;
+
+            var t = (ex * dvy - ey * dvx) / det;
+            if (t < -Tolerance.Epsilon)
+                return double.MaxValue;
+
+            var s = (dirX * dvy - dirY * dvx) / det;
+            if (s < -Tolerance.Epsilon || s > 1.0 + Tolerance.Epsilon)
+                return double.MaxValue;
+
+            if (t > Tolerance.Epsilon) return t;
+            if (t >= -Tolerance.Epsilon) return 0;
+            return double.MaxValue;
+        }
+
         /// <summary>
         /// Computes the minimum translation distance along a push direction before
         /// any edge of movingLines contacts any edge of stationaryLines.
@@ -329,10 +362,10 @@ namespace OpenNest.Geometry
         {
             switch (direction)
             {
-                case PushDirection.Left:  return box.Left - boundary.Left;
+                case PushDirection.Left: return box.Left - boundary.Left;
                 case PushDirection.Right: return boundary.Right - box.Right;
-                case PushDirection.Up:    return boundary.Top - box.Top;
-                case PushDirection.Down:  return box.Bottom - boundary.Bottom;
+                case PushDirection.Up: return boundary.Top - box.Top;
+                case PushDirection.Down: return box.Bottom - boundary.Bottom;
                 default: return double.MaxValue;
             }
         }
@@ -341,10 +374,10 @@ namespace OpenNest.Geometry
         {
             switch (direction)
             {
-                case PushDirection.Left:  return new Vector(-distance, 0);
+                case PushDirection.Left: return new Vector(-distance, 0);
                 case PushDirection.Right: return new Vector(distance, 0);
-                case PushDirection.Up:    return new Vector(0, distance);
-                case PushDirection.Down:  return new Vector(0, -distance);
+                case PushDirection.Up: return new Vector(0, distance);
+                case PushDirection.Down: return new Vector(0, -distance);
                 default: return new Vector();
             }
         }
@@ -353,14 +386,143 @@ namespace OpenNest.Geometry
         {
             switch (direction)
             {
-                case PushDirection.Left:  return from.Left - to.Right;
+                case PushDirection.Left: return from.Left - to.Right;
                 case PushDirection.Right: return to.Left - from.Right;
-                case PushDirection.Up:    return to.Bottom - from.Top;
-                case PushDirection.Down:  return from.Bottom - to.Top;
+                case PushDirection.Up: return to.Bottom - from.Top;
+                case PushDirection.Down: return from.Bottom - to.Top;
                 default: return double.MaxValue;
             }
         }
 
+        #region Generalized direction (Vector) overloads
+
+        /// <summary>
+        /// Computes how far a box can travel along the given unit direction
+        /// before exiting the boundary box.
+        /// </summary>
+        public static double EdgeDistance(Box box, Box boundary, Vector direction)
+        {
+            var dist = double.MaxValue;
+
+            if (direction.X < -Tolerance.Epsilon)
+            {
+                var d = (box.Left - boundary.Left) / -direction.X;
+                if (d < dist) dist = d;
+            }
+            else if (direction.X > Tolerance.Epsilon)
+            {
+                var d = (boundary.Right - box.Right) / direction.X;
+                if (d < dist) dist = d;
+            }
+
+            if (direction.Y < -Tolerance.Epsilon)
+            {
+                var d = (box.Bottom - boundary.Bottom) / -direction.Y;
+                if (d < dist) dist = d;
+            }
+            else if (direction.Y > Tolerance.Epsilon)
+            {
+                var d = (boundary.Top - box.Top) / direction.Y;
+                if (d < dist) dist = d;
+            }
+
+            return dist < 0 ? 0 : dist;
+        }
+
+        /// <summary>
+        /// Computes the directional gap between two boxes along an arbitrary unit direction.
+        /// Positive means 'to' is ahead of 'from' in the push direction.
+        /// </summary>
+        public static double DirectionalGap(Box from, Box to, Vector direction)
+        {
+            var fromMax = BoxProjectionMax(from, direction.X, direction.Y);
+            var toMin = BoxProjectionMin(to, direction.X, direction.Y);
+            return toMin - fromMax;
+        }
+
+        /// <summary>
+        /// Returns true if two boxes overlap when projected onto the axis
+        /// perpendicular to the given unit direction.
+        /// </summary>
+        public static bool PerpendicularOverlap(Box a, Box b, Vector direction)
+        {
+            var px = -direction.Y;
+            var py = direction.X;
+
+            var aMin = BoxProjectionMin(a, px, py);
+            var aMax = BoxProjectionMax(a, px, py);
+            var bMin = BoxProjectionMin(b, px, py);
+            var bMax = BoxProjectionMax(b, px, py);
+
+            return aMin <= bMax + Tolerance.Epsilon && bMin <= aMax + Tolerance.Epsilon;
+        }
+
+        /// <summary>
+        /// Computes the minimum translation distance along an arbitrary unit direction
+        /// before any edge of movingLines contacts any edge of stationaryLines.
+        /// </summary>
+        public static double DirectionalDistance(List<Line> movingLines, List<Line> stationaryLines, Vector direction)
+        {
+            var minDist = double.MaxValue;
+            var dirX = direction.X;
+            var dirY = direction.Y;
+
+            var movingVertices = new HashSet<Vector>();
+            for (var i = 0; i < movingLines.Count; i++)
+            {
+                movingVertices.Add(movingLines[i].pt1);
+                movingVertices.Add(movingLines[i].pt2);
+            }
+
+            foreach (var mv in movingVertices)
+            {
+                for (var i = 0; i < stationaryLines.Count; i++)
+                {
+                    var e = stationaryLines[i];
+                    var d = RayEdgeDistance(mv.X, mv.Y, e.pt1.X, e.pt1.Y, e.pt2.X, e.pt2.Y, dirX, dirY);
+                    if (d < minDist) minDist = d;
+                }
+            }
+
+            var oppX = -dirX;
+            var oppY = -dirY;
+
+            var stationaryVertices = new HashSet<Vector>();
+            for (var i = 0; i < stationaryLines.Count; i++)
+            {
+                stationaryVertices.Add(stationaryLines[i].pt1);
+                stationaryVertices.Add(stationaryLines[i].pt2);
+            }
+
+            foreach (var sv in stationaryVertices)
+            {
+                for (var i = 0; i < movingLines.Count; i++)
+                {
+                    var e = movingLines[i];
+                    var d = RayEdgeDistance(sv.X, sv.Y, e.pt1.X, e.pt1.Y, e.pt2.X, e.pt2.Y, oppX, oppY);
+                    if (d < minDist) minDist = d;
+                }
+            }
+
+            return minDist;
+        }
+
+        private static double BoxProjectionMin(Box box, double dx, double dy)
+        {
+            var x = dx >= 0 ? box.Left : box.Right;
+            var y = dy >= 0 ? box.Bottom : box.Top;
+            return x * dx + y * dy;
+        }
+
+        private static double BoxProjectionMax(Box box, double dx, double dy)
+        {
+            var x = dx >= 0 ? box.Right : box.Left;
+            var y = dy >= 0 ? box.Top : box.Bottom;
+            return x * dx + y * dy;
+        }
+
+        #endregion
+
         public static double ClosestDistanceLeft(Box box, List<Box> boxes)
         {
             var closestDistance = double.MaxValue;

OpenNest.Core/Geometry/Vector.cs

@@ -1,5 +1,5 @@
-using System;
-using OpenNest.Math;
+using OpenNest.Math;
+using System;
 
 namespace OpenNest.Geometry
 {

OpenNest.Core/Math/Angle.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace OpenNest.Math
+namespace OpenNest.Math
 {
     public static class Angle
     {

OpenNest.Core/Math/Tolerance.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace OpenNest.Math
+namespace OpenNest.Math
 {
     public static class Tolerance
     {

OpenNest.Core/Math/Trigonometry.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace OpenNest.Math
+namespace OpenNest.Math
 {
     public static class Trigonometry
     {

OpenNest.Core/Nest.cs

@@ -1,6 +1,6 @@
-using System;
-using OpenNest.Collections;
+using OpenNest.Collections;
 using OpenNest.Geometry;
+using System;
 
 namespace OpenNest
 {
@@ -36,6 +36,8 @@ namespace OpenNest
 
         public string Notes { get; set; }
 
+        public string AssistGas { get; set; } = "";
+
         public Units Units { get; set; }
 
         public DateTime DateCreated { get; set; }

OpenNest.Core/NestConstraints.cs

@@ -1,5 +1,4 @@
-using System;
-using OpenNest.Math;
+using OpenNest.Math;
 
 namespace OpenNest
 {

OpenNest.Core/Part.cs

@@ -1,8 +1,8 @@
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.CNC;
+using OpenNest.CNC;
 using OpenNest.Converters;
 using OpenNest.Geometry;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace OpenNest
 {
@@ -20,6 +20,7 @@ namespace OpenNest
     public class Part : IPart, IBoundable
     {
         private Vector location;
+        private bool ownsProgram;
 
         public readonly Drawing BaseDrawing;
 
@@ -32,6 +33,7 @@ namespace OpenNest
         {
             BaseDrawing = baseDrawing;
             Program = baseDrawing.Program.Clone() as Program;
+            ownsProgram = true;
             this.location = location;
             UpdateBounds();
         }
@@ -67,6 +69,7 @@ namespace OpenNest
         /// <param name="angle">Angle of rotation in radians.</param>
         public void Rotate(double angle)
         {
+            EnsureOwnedProgram();
             Program.Rotate(angle);
             location = Location.Rotate(angle);
             UpdateBounds();
@@ -79,6 +82,7 @@ namespace OpenNest
         /// <param name="origin">The origin to rotate the part around.</param>
         public void Rotate(double angle, Vector origin)
         {
+            EnsureOwnedProgram();
             Program.Rotate(angle);
             location = Location.Rotate(angle, origin);
             UpdateBounds();
@@ -222,6 +226,15 @@ namespace OpenNest
             return part;
         }
 
+        private void EnsureOwnedProgram()
+        {
+            if (!ownsProgram)
+            {
+                Program = Program.Clone() as Program;
+                ownsProgram = true;
+            }
+        }
+
         private Part(Drawing baseDrawing, Program program, Vector location, Box boundingBox)
         {
             BaseDrawing = baseDrawing;

OpenNest.Core/PartGeometry.cs

@@ -1,7 +1,7 @@
-using System.Collections.Generic;
-using System.Linq;
 using OpenNest.Converters;
 using OpenNest.Geometry;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace OpenNest
 {
@@ -49,7 +49,7 @@ namespace OpenNest
             {
                 // Add chord tolerance to compensate for inscribed polygon chords
                 // being inside the actual offset arcs.
-                var offsetEntity = shape.OffsetEntity(spacing + chordTolerance, OffsetSide.Left) as Shape;
+                var offsetEntity = shape.OffsetOutward(spacing + chordTolerance);
 
                 if (offsetEntity == null)
                     continue;
@@ -71,7 +71,7 @@ namespace OpenNest
 
             foreach (var shape in shapes)
             {
-                var offsetEntity = shape.OffsetEntity(spacing + chordTolerance, OffsetSide.Left) as Shape;
+                var offsetEntity = shape.OffsetOutward(spacing + chordTolerance);
 
                 if (offsetEntity == null)
                     continue;
@@ -85,6 +85,73 @@ namespace OpenNest
             return lines;
         }
 
+        public static List<Line> GetPartLines(Part part, Vector facingDirection, double chordTolerance = 0.001)
+        {
+            var entities = ConvertProgram.ToGeometry(part.Program);
+            var shapes = ShapeBuilder.GetShapes(entities.Where(e => e.Layer != SpecialLayers.Rapid));
+            var lines = new List<Line>();
+
+            foreach (var shape in shapes)
+            {
+                var polygon = shape.ToPolygonWithTolerance(chordTolerance);
+                polygon.Offset(part.Location);
+                lines.AddRange(GetDirectionalLines(polygon, facingDirection));
+            }
+
+            return lines;
+        }
+
+        public static List<Line> GetOffsetPartLines(Part part, double spacing, Vector facingDirection, double chordTolerance = 0.001)
+        {
+            var entities = ConvertProgram.ToGeometry(part.Program);
+            var shapes = ShapeBuilder.GetShapes(entities.Where(e => e.Layer != SpecialLayers.Rapid));
+            var lines = new List<Line>();
+
+            foreach (var shape in shapes)
+            {
+                var offsetEntity = shape.OffsetOutward(spacing + chordTolerance);
+
+                if (offsetEntity == null)
+                    continue;
+
+                var polygon = offsetEntity.ToPolygonWithTolerance(chordTolerance);
+                polygon.RemoveSelfIntersections();
+                polygon.Offset(part.Location);
+                lines.AddRange(GetDirectionalLines(polygon, facingDirection));
+            }
+
+            return lines;
+        }
+
+        /// <summary>
+        /// Returns only polygon edges whose outward normal faces the specified direction vector.
+        /// </summary>
+        private static List<Line> GetDirectionalLines(Polygon polygon, Vector direction)
+        {
+            if (polygon.Vertices.Count < 3)
+                return polygon.ToLines();
+
+            var sign = polygon.RotationDirection() == RotationType.CCW ? 1.0 : -1.0;
+            var lines = new List<Line>();
+            var last = polygon.Vertices[0];
+
+            for (var i = 1; i < polygon.Vertices.Count; i++)
+            {
+                var current = polygon.Vertices[i];
+                var edx = current.X - last.X;
+                var edy = current.Y - last.Y;
+
+                var keep = sign * (edy * direction.X - edx * direction.Y) > 0;
+
+                if (keep)
+                    lines.Add(new Line(last, current));
+
+                last = current;
+            }
+
+            return lines;
+        }
+
         /// <summary>
         /// Returns only polygon edges whose outward normal faces the specified direction.
         /// </summary>
@@ -107,10 +174,10 @@ namespace OpenNest
 
                 switch (facingDirection)
                 {
-                    case PushDirection.Left:  keep = -sign * dy > 0; break;
-                    case PushDirection.Right: keep =  sign * dy > 0; break;
-                    case PushDirection.Up:    keep = -sign * dx > 0; break;
-                    case PushDirection.Down:  keep =  sign * dx > 0; break;
+                    case PushDirection.Left: keep = -sign * dy > 0; break;
+                    case PushDirection.Right: keep = sign * dy > 0; break;
+                    case PushDirection.Up: keep = -sign * dx > 0; break;
+                    case PushDirection.Down: keep = sign * dx > 0; break;
                     default: keep = true; break;
                 }
 

OpenNest.Core/Plate.cs

@@ -1,9 +1,9 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using OpenNest.Collections;
+using OpenNest.Collections;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace OpenNest
 {
@@ -47,17 +47,20 @@ namespace OpenNest
             Parts = new ObservableList<Part>();
             Parts.ItemAdded += Parts_PartAdded;
             Parts.ItemRemoved += Parts_PartRemoved;
+            CutOffs = new ObservableList<CutOff>();
             Quadrant = 1;
         }
 
         private void Parts_PartAdded(object sender, ItemAddedEventArgs<Part> e)
         {
-            e.Item.BaseDrawing.Quantity.Nested += Quantity;
+            if (!e.Item.BaseDrawing.IsCutOff)
+                e.Item.BaseDrawing.Quantity.Nested += Quantity;
         }
 
         private void Parts_PartRemoved(object sender, ItemRemovedEventArgs<Part> e)
         {
-            e.Item.BaseDrawing.Quantity.Nested -= Quantity;
+            if (!e.Item.BaseDrawing.IsCutOff)
+                e.Item.BaseDrawing.Quantity.Nested -= Quantity;
         }
 
         /// <summary>
@@ -85,11 +88,102 @@ namespace OpenNest
         /// </summary>
         public Material Material { get; set; }
 
+        /// <summary>
+        /// Material grain direction in radians. 0 = horizontal.
+        /// </summary>
+        public double GrainAngle { get; set; }
+
         /// <summary>
         /// The parts that the plate contains.
         /// </summary>
         public ObservableList<Part> Parts { get; set; }
 
+        /// <summary>
+        /// The cut-off lines defined on this plate.
+        /// </summary>
+        public ObservableList<CutOff> CutOffs { get; set; }
+
+        /// <summary>
+        /// Regenerates all cut-off drawings and materializes them as parts.
+        /// Existing cut-off parts are removed first, then each cut-off is
+        /// regenerated and added back if it produces any geometry.
+        /// </summary>
+        public void RegenerateCutOffs(CutOffSettings settings)
+        {
+            // Remove existing cut-off parts
+            for (var i = Parts.Count - 1; i >= 0; i--)
+            {
+                if (Parts[i].BaseDrawing.IsCutOff)
+                    Parts.RemoveAt(i);
+            }
+
+            var cache = BuildPerimeterCache(this);
+
+            // Regenerate and materialize each cut-off
+            foreach (var cutoff in CutOffs)
+            {
+                cutoff.Regenerate(this, settings, cache);
+
+                if (cutoff.Drawing.Program.Codes.Count == 0)
+                    continue;
+
+                var part = new Part(cutoff.Drawing);
+                Parts.Add(part);
+            }
+        }
+
+        /// <summary>
+        /// Builds a dictionary mapping each non-cut-off part to its perimeter entity.
+        /// Closed shapes use ShapeProfile; open contours fall back to ConvexHull.
+        /// </summary>
+        public static Dictionary<Part, Geometry.Entity> BuildPerimeterCache(Plate plate)
+        {
+            var cache = new Dictionary<Part, Geometry.Entity>();
+
+            foreach (var part in plate.Parts)
+            {
+                if (part.BaseDrawing.IsCutOff)
+                    continue;
+
+                Geometry.Entity perimeter = null;
+                try
+                {
+                    var entities = Converters.ConvertProgram.ToGeometry(part.Program)
+                        .Where(e => e.Layer != SpecialLayers.Rapid)
+                        .ToList();
+
+                    if (entities.Count > 0)
+                    {
+                        var profile = new Geometry.ShapeProfile(entities);
+
+                        if (profile.Perimeter.IsClosed())
+                        {
+                            perimeter = profile.Perimeter;
+                            perimeter.Offset(part.Location);
+                        }
+                        else
+                        {
+                            var points = entities.CollectPoints();
+                            if (points.Count >= 3)
+                            {
+                                var hull = Geometry.ConvexHull.Compute(points);
+                                hull.Offset(part.Location);
+                                perimeter = hull;
+                            }
+                        }
+                    }
+                }
+                catch
+                {
+                    perimeter = null;
+                }
+
+                cache[part] = perimeter;
+            }
+
+            return cache;
+        }
+
         /// <summary>
         /// The number of times to cut the plate.
         /// </summary>
@@ -240,11 +334,20 @@ namespace OpenNest
         /// <param name="angle"></param>
         public void Rotate(double angle)
         {
-            for (int i = 0; i < Parts.Count; ++i)
+            for (var i = Parts.Count - 1; i >= 0; i--)
+            {
+                if (Parts[i].BaseDrawing.IsCutOff)
+                    Parts.RemoveAt(i);
+            }
+
+            for (var i = 0; i < Parts.Count; ++i)
             {
                 var part = Parts[i];
                 part.Rotate(angle);
             }
+
+            foreach (var cutoff in CutOffs)
+                cutoff.Position = cutoff.Position.Rotate(angle);
         }
 
         /// <summary>
@@ -254,11 +357,24 @@ namespace OpenNest
         /// <param name="origin"></param>
         public void Rotate(double angle, Vector origin)
         {
-            for (int i = 0; i < Parts.Count; ++i)
+            for (var i = Parts.Count - 1; i >= 0; i--)
+            {
+                if (Parts[i].BaseDrawing.IsCutOff)
+                    Parts.RemoveAt(i);
+            }
+
+            for (var i = 0; i < Parts.Count; ++i)
             {
                 var part = Parts[i];
                 part.Rotate(angle, origin);
             }
+
+            foreach (var cutoff in CutOffs)
+            {
+                var pos = cutoff.Position - origin;
+                pos = pos.Rotate(angle);
+                cutoff.Position = pos + origin;
+            }
         }
 
         /// <summary>
@@ -268,11 +384,22 @@ namespace OpenNest
         /// <param name="y"></param>
         public void Offset(double x, double y)
         {
-            for (int i = 0; i < Parts.Count; ++i)
+            // Remove cut-off parts before transforming
+            for (var i = Parts.Count - 1; i >= 0; i--)
+            {
+                if (Parts[i].BaseDrawing.IsCutOff)
+                    Parts.RemoveAt(i);
+            }
+
+            for (var i = 0; i < Parts.Count; ++i)
             {
                 var part = Parts[i];
                 part.Offset(x, y);
             }
+
+            // Transform cut-off positions
+            foreach (var cutoff in CutOffs)
+                cutoff.Position = new Vector(cutoff.Position.X + x, cutoff.Position.Y + y);
         }
 
         /// <summary>
@@ -281,11 +408,20 @@ namespace OpenNest
         /// <param name="voffset"></param>
         public void Offset(Vector voffset)
         {
-            for (int i = 0; i < Parts.Count; ++i)
+            for (var i = Parts.Count - 1; i >= 0; i--)
+            {
+                if (Parts[i].BaseDrawing.IsCutOff)
+                    Parts.RemoveAt(i);
+            }
+
+            for (var i = 0; i < Parts.Count; ++i)
             {
                 var part = Parts[i];
                 part.Offset(voffset);
             }
+
+            foreach (var cutoff in CutOffs)
+                cutoff.Position = new Vector(cutoff.Position.X + voffset.X, cutoff.Position.Y + voffset.Y);
         }
 
         /// <summary>
@@ -454,24 +590,23 @@ namespace OpenNest
         /// <returns>Returns a number between 0.0 and 1.0</returns>
         public double Utilization()
         {
-            return Parts.Sum(part => part.BaseDrawing.Area) / Area();
+            return Parts.Where(p => !p.BaseDrawing.IsCutOff).Sum(part => part.BaseDrawing.Area) / Area();
         }
 
         public bool HasOverlappingParts(out List<Vector> pts)
         {
             pts = new List<Vector>();
+            var realParts = Parts.Where(p => !p.BaseDrawing.IsCutOff).ToList();
 
-            for (int i = 0; i < Parts.Count; i++)
+            for (var i = 0; i < realParts.Count; i++)
             {
-                var part1 = Parts[i];
+                var part1 = realParts[i];
 
-                for (int j = i + 1; j < Parts.Count; j++)
+                for (var j = i + 1; j < realParts.Count; j++)
                 {
-                    var part2 = Parts[j];
+                    var part2 = realParts[j];
 
-                    List<Vector> pts2;
-
-                    if (part1.Intersects(part2, out pts2))
+                    if (part1.Intersects(part2, out var pts2))
                         pts.AddRange(pts2);
                 }
             }

OpenNest.Core/Sequence.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
-using OpenNest.Geometry;
+using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest
 {

OpenNest.Core/Shapes/CircleShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/FlangeShape.cs

@@ -1,6 +1,5 @@
-using System;
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/IsoscelesTriangleShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/LShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/OctagonShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/RectangleShape.cs

@@ -1,21 +1,21 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {
     public class RectangleShape : ShapeDefinition
     {
+        public double Length { get; set; }
         public double Width { get; set; }
-        public double Height { get; set; }
 
         public override Drawing GetDrawing()
         {
             var entities = new List<Entity>
             {
-                new Line(0, 0, Width, 0),
-                new Line(Width, 0, Width, Height),
-                new Line(Width, Height, 0, Height),
-                new Line(0, Height, 0, 0)
+                new Line(0, 0, Length, 0),
+                new Line(Length, 0, Length, Width),
+                new Line(Length, Width, 0, Width),
+                new Line(0, Width, 0, 0)
             };
 
             return CreateDrawing(entities);

OpenNest.Core/Shapes/RightTriangleShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/RingShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/RoundedRectangleShape.cs

@@ -1,13 +1,13 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {
     public class RoundedRectangleShape : ShapeDefinition
     {
+        public double Length { get; set; }
         public double Width { get; set; }
-        public double Height { get; set; }
         public double Radius { get; set; }
 
         public override Drawing GetDrawing()
@@ -17,36 +17,36 @@ namespace OpenNest.Shapes
 
             if (r <= 0)
             {
-                entities.Add(new Line(0, 0, Width, 0));
-                entities.Add(new Line(Width, 0, Width, Height));
-                entities.Add(new Line(Width, Height, 0, Height));
-                entities.Add(new Line(0, Height, 0, 0));
+                entities.Add(new Line(0, 0, Length, 0));
+                entities.Add(new Line(Length, 0, Length, Width));
+                entities.Add(new Line(Length, Width, 0, Width));
+                entities.Add(new Line(0, Width, 0, 0));
             }
             else
             {
                 // Bottom edge (left to right, above bottom-left arc to bottom-right arc)
-                entities.Add(new Line(r, 0, Width - r, 0));
+                entities.Add(new Line(r, 0, Length - r, 0));
 
-                // Bottom-right corner arc: center at (Width-r, r), from 270deg to 360deg
-                entities.Add(new Arc(Width - r, r, r,
+                // Bottom-right corner arc: center at (Length-r, r), from 270deg to 360deg
+                entities.Add(new Arc(Length - r, r, r,
                     Angle.ToRadians(270), Angle.ToRadians(360)));
 
                 // Right edge
-                entities.Add(new Line(Width, r, Width, Height - r));
+                entities.Add(new Line(Length, r, Length, Width - r));
 
-                // Top-right corner arc: center at (Width-r, Height-r), from 0deg to 90deg
-                entities.Add(new Arc(Width - r, Height - r, r,
+                // Top-right corner arc: center at (Length-r, Width-r), from 0deg to 90deg
+                entities.Add(new Arc(Length - r, Width - r, r,
                     Angle.ToRadians(0), Angle.ToRadians(90)));
 
                 // Top edge (right to left)
-                entities.Add(new Line(Width - r, Height, r, Height));
+                entities.Add(new Line(Length - r, Width, r, Width));
 
-                // Top-left corner arc: center at (r, Height-r), from 90deg to 180deg
-                entities.Add(new Arc(r, Height - r, r,
+                // Top-left corner arc: center at (r, Width-r), from 90deg to 180deg
+                entities.Add(new Arc(r, Width - r, r,
                     Angle.ToRadians(90), Angle.ToRadians(180)));
 
                 // Left edge
-                entities.Add(new Line(0, Height - r, 0, r));
+                entities.Add(new Line(0, Width - r, 0, r));
 
                 // Bottom-left corner arc: center at (r, r), from 180deg to 270deg
                 entities.Add(new Arc(r, r, r,

OpenNest.Core/Shapes/ShapeDefinition.cs

@@ -1,9 +1,9 @@
+using OpenNest.Converters;
+using OpenNest.Geometry;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text.Json;
-using OpenNest.Converters;
-using OpenNest.Geometry;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/TShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/Shapes/TrapezoidShape.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
+using System.Collections.Generic;
 
 namespace OpenNest.Shapes
 {

OpenNest.Core/SpecialLayers.cs

@@ -1,21 +1,22 @@
-using OpenNest.Geometry;
+using System.Drawing;
+using OpenNest.Geometry;
 
 namespace OpenNest
 {
     public static class SpecialLayers
     {
-        public static readonly Layer Default = new Layer("0");
+        public static readonly Layer Default = new Layer("0") { Color = Color.White };
 
-        public static readonly Layer Cut = new Layer("CUT");
+        public static readonly Layer Cut = new Layer("CUT") { Color = Color.White };
 
-        public static readonly Layer Rapid = new Layer("RAPID");
+        public static readonly Layer Rapid = new Layer("RAPID") { Color = Color.Gray };
 
-        public static readonly Layer Display = new Layer("DISPLAY");
+        public static readonly Layer Display = new Layer("DISPLAY") { Color = Color.Cyan };
 
-        public static readonly Layer Leadin = new Layer("LEADIN");
+        public static readonly Layer Leadin = new Layer("LEADIN") { Color = Color.Yellow };
 
-        public static readonly Layer Leadout = new Layer("LEADOUT");
+        public static readonly Layer Leadout = new Layer("LEADOUT") { Color = Color.Yellow };
 
-        public static readonly Layer Scribe = new Layer("SCRIBE");
+        public static readonly Layer Scribe = new Layer("SCRIBE") { Color = Color.Magenta };
     }
 }

OpenNest.Core/Splitting/AutoSplitCalculator.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+public static class AutoSplitCalculator
+{
+    public static List<SplitLine> FitToPlate(Box partBounds, double plateWidth, double plateHeight,
+        double edgeSpacing, double featureOverhang)
+    {
+        var usableWidth = plateWidth - 2 * edgeSpacing - featureOverhang;
+        var usableHeight = plateHeight - 2 * edgeSpacing - featureOverhang;
+
+        var lines = new List<SplitLine>();
+
+        var verticalSplits = usableWidth > 0 ? (int)System.Math.Ceiling(partBounds.Width / usableWidth) - 1 : 0;
+        var horizontalSplits = usableHeight > 0 ? (int)System.Math.Ceiling(partBounds.Length / usableHeight) - 1 : 0;
+
+        if (verticalSplits < 0) verticalSplits = 0;
+        if (horizontalSplits < 0) horizontalSplits = 0;
+
+        for (var i = 1; i <= verticalSplits; i++)
+            lines.Add(new SplitLine(partBounds.X + usableWidth * i, CutOffAxis.Vertical));
+
+        for (var i = 1; i <= horizontalSplits; i++)
+            lines.Add(new SplitLine(partBounds.Y + usableHeight * i, CutOffAxis.Horizontal));
+
+        return lines;
+    }
+
+    public static List<SplitLine> SplitByCount(Box partBounds, int horizontalPieces, int verticalPieces)
+    {
+        var lines = new List<SplitLine>();
+
+        if (verticalPieces > 1)
+        {
+            var spacing = partBounds.Width / verticalPieces;
+            for (var i = 1; i < verticalPieces; i++)
+                lines.Add(new SplitLine(partBounds.X + spacing * i, CutOffAxis.Vertical));
+        }
+
+        if (horizontalPieces > 1)
+        {
+            var spacing = partBounds.Length / horizontalPieces;
+            for (var i = 1; i < horizontalPieces; i++)
+                lines.Add(new SplitLine(partBounds.Y + spacing * i, CutOffAxis.Horizontal));
+        }
+
+        return lines;
+    }
+}

OpenNest.Core/Splitting/DrawingSplitter.cs

@@ -0,0 +1,565 @@
+using System.Collections.Generic;
+using System.Linq;
+using OpenNest.Converters;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+/// <summary>
+/// Splits a Drawing into multiple pieces along split lines with optional feature geometry.
+/// </summary>
+public static class DrawingSplitter
+{
+    public static List<Drawing> Split(Drawing drawing, List<SplitLine> splitLines, SplitParameters parameters)
+    {
+        if (splitLines.Count == 0)
+            return new List<Drawing> { drawing };
+
+        var profile = BuildProfile(drawing);
+        DecomposeCircles(profile);
+
+        var perimeter = profile.Perimeter;
+        var bounds = perimeter.BoundingBox;
+
+        var sortedLines = splitLines
+            .Where(l => IsLineInsideBounds(l, bounds))
+            .OrderBy(l => l.Position)
+            .ToList();
+
+        if (sortedLines.Count == 0)
+            return new List<Drawing> { drawing };
+
+        var regions = BuildClipRegions(sortedLines, bounds);
+        var feature = GetFeature(parameters.Type);
+
+        var results = new List<Drawing>();
+        var pieceIndex = 1;
+
+        foreach (var region in regions)
+        {
+            var pieceEntities = ClipPerimeterToRegion(perimeter, region, sortedLines, feature, parameters);
+            if (pieceEntities.Count == 0)
+                continue;
+
+            var cutoutEntities = CollectCutouts(profile.Cutouts, region, sortedLines);
+
+            var allEntities = new List<Entity>();
+            allEntities.AddRange(pieceEntities);
+            allEntities.AddRange(cutoutEntities);
+
+            var piece = BuildPieceDrawing(drawing, allEntities, pieceIndex, region);
+            results.Add(piece);
+            pieceIndex++;
+        }
+
+        return results;
+    }
+
+    private static ShapeProfile BuildProfile(Drawing drawing)
+    {
+        var entities = ConvertProgram.ToGeometry(drawing.Program)
+            .Where(e => e.Layer != SpecialLayers.Rapid)
+            .ToList();
+        return new ShapeProfile(entities);
+    }
+
+    private static List<Entity> CollectCutouts(List<Shape> cutouts, Box region, List<SplitLine> splitLines)
+    {
+        var entities = new List<Entity>();
+        foreach (var cutout in cutouts)
+        {
+            if (IsCutoutInRegion(cutout, region))
+                entities.AddRange(cutout.Entities);
+            else if (DoesCutoutCrossSplitLine(cutout, splitLines))
+            {
+                var clipped = ClipCutoutToRegion(cutout, region, splitLines);
+                if (clipped.Count > 0)
+                    entities.AddRange(clipped);
+            }
+        }
+        return entities;
+    }
+
+    private static Drawing BuildPieceDrawing(Drawing source, List<Entity> entities, int pieceIndex, Box region)
+    {
+        var pieceBounds = entities.Select(e => e.BoundingBox).ToList().GetBoundingBox();
+        var offsetX = -pieceBounds.X;
+        var offsetY = -pieceBounds.Y;
+
+        foreach (var e in entities)
+            e.Offset(offsetX, offsetY);
+
+        var pgm = ConvertGeometry.ToProgram(entities);
+        var piece = new Drawing($"{source.Name}-{pieceIndex}", pgm);
+        piece.Color = source.Color;
+        piece.Priority = source.Priority;
+        piece.Material = source.Material;
+        piece.Constraints = source.Constraints;
+        piece.Customer = source.Customer;
+        piece.Source = source.Source;
+        piece.Quantity.Required = source.Quantity.Required;
+
+        if (source.Bends != null && source.Bends.Count > 0)
+        {
+            piece.Bends = new List<Bending.Bend>();
+            foreach (var bend in source.Bends)
+            {
+                var clipped = ClipLineToBox(bend.StartPoint, bend.EndPoint, region);
+                if (clipped == null)
+                    continue;
+
+                piece.Bends.Add(new Bending.Bend
+                {
+                    StartPoint = new Vector(clipped.Value.Start.X + offsetX, clipped.Value.Start.Y + offsetY),
+                    EndPoint = new Vector(clipped.Value.End.X + offsetX, clipped.Value.End.Y + offsetY),
+                    Direction = bend.Direction,
+                    Angle = bend.Angle,
+                    Radius = bend.Radius,
+                    NoteText = bend.NoteText,
+                });
+            }
+        }
+
+        return piece;
+    }
+
+    /// <summary>
+    /// Clips a line segment to an axis-aligned box using Liang-Barsky algorithm.
+    /// Returns the clipped start/end or null if the line is entirely outside.
+    /// </summary>
+    private static (Vector Start, Vector End)? ClipLineToBox(Vector start, Vector end, Box box)
+    {
+        var dx = end.X - start.X;
+        var dy = end.Y - start.Y;
+        double t0 = 0, t1 = 1;
+
+        double[] p = { -dx, dx, -dy, dy };
+        double[] q = { start.X - box.Left, box.Right - start.X, start.Y - box.Bottom, box.Top - start.Y };
+
+        for (var i = 0; i < 4; i++)
+        {
+            if (System.Math.Abs(p[i]) < Math.Tolerance.Epsilon)
+            {
+                if (q[i] < -Math.Tolerance.Epsilon)
+                    return null;
+            }
+            else
+            {
+                var t = q[i] / p[i];
+                if (p[i] < 0)
+                    t0 = System.Math.Max(t0, t);
+                else
+                    t1 = System.Math.Min(t1, t);
+
+                if (t0 > t1)
+                    return null;
+            }
+        }
+
+        var clippedStart = new Vector(start.X + t0 * dx, start.Y + t0 * dy);
+        var clippedEnd = new Vector(start.X + t1 * dx, start.Y + t1 * dy);
+        return (clippedStart, clippedEnd);
+    }
+
+    private static void DecomposeCircles(ShapeProfile profile)
+    {
+        DecomposeCirclesInShape(profile.Perimeter);
+        foreach (var cutout in profile.Cutouts)
+            DecomposeCirclesInShape(cutout);
+    }
+
+    private static void DecomposeCirclesInShape(Shape shape)
+    {
+        for (var i = shape.Entities.Count - 1; i >= 0; i--)
+        {
+            if (shape.Entities[i] is Circle circle)
+            {
+                var arc1 = new Arc(circle.Center, circle.Radius, 0, System.Math.PI);
+                var arc2 = new Arc(circle.Center, circle.Radius, System.Math.PI, System.Math.PI * 2);
+                shape.Entities.RemoveAt(i);
+                shape.Entities.Insert(i, arc2);
+                shape.Entities.Insert(i, arc1);
+            }
+        }
+    }
+
+    private static bool IsLineInsideBounds(SplitLine line, Box bounds)
+    {
+        return line.Axis == CutOffAxis.Vertical
+            ? line.Position > bounds.Left + OpenNest.Math.Tolerance.Epsilon
+              && line.Position < bounds.Right - OpenNest.Math.Tolerance.Epsilon
+            : line.Position > bounds.Bottom + OpenNest.Math.Tolerance.Epsilon
+              && line.Position < bounds.Top - OpenNest.Math.Tolerance.Epsilon;
+    }
+
+    private static List<Box> BuildClipRegions(List<SplitLine> sortedLines, Box bounds)
+    {
+        var verticals = sortedLines.Where(l => l.Axis == CutOffAxis.Vertical).OrderBy(l => l.Position).ToList();
+        var horizontals = sortedLines.Where(l => l.Axis == CutOffAxis.Horizontal).OrderBy(l => l.Position).ToList();
+
+        var xEdges = new List<double> { bounds.Left };
+        xEdges.AddRange(verticals.Select(v => v.Position));
+        xEdges.Add(bounds.Right);
+
+        var yEdges = new List<double> { bounds.Bottom };
+        yEdges.AddRange(horizontals.Select(h => h.Position));
+        yEdges.Add(bounds.Top);
+
+        var regions = new List<Box>();
+        for (var yi = 0; yi < yEdges.Count - 1; yi++)
+            for (var xi = 0; xi < xEdges.Count - 1; xi++)
+                regions.Add(new Box(xEdges[xi], yEdges[yi], xEdges[xi + 1] - xEdges[xi], yEdges[yi + 1] - yEdges[yi]));
+
+        return regions;
+    }
+
+    /// <summary>
+    /// Clip perimeter to a region by walking entities, splitting at split line crossings,
+    /// and stitching in feature edges. No polygon clipping library needed.
+    /// </summary>
+    private static List<Entity> ClipPerimeterToRegion(Shape perimeter, Box region,
+        List<SplitLine> splitLines, ISplitFeature feature, SplitParameters parameters)
+    {
+        var boundarySplitLines = GetBoundarySplitLines(region, splitLines);
+        var entities = new List<Entity>();
+        var splitPoints = new List<(Vector Point, SplitLine Line, bool IsExit)>();
+
+        foreach (var entity in perimeter.Entities)
+        {
+            ProcessEntity(entity, region, boundarySplitLines, entities, splitPoints);
+        }
+
+        if (entities.Count == 0)
+            return new List<Entity>();
+
+        InsertFeatureEdges(entities, splitPoints, region, boundarySplitLines, feature, parameters);
+        EnsurePerimeterWinding(entities);
+        return entities;
+    }
+
+    private static void ProcessEntity(Entity entity, Box region,
+        List<SplitLine> boundarySplitLines, List<Entity> entities,
+        List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints)
+    {
+        // Find the first boundary split line this entity crosses
+        SplitLine crossedLine = null;
+        Vector? intersectionPt = null;
+
+        foreach (var sl in boundarySplitLines)
+        {
+            if (SplitLineIntersect.CrossesSplitLine(entity, sl))
+            {
+                var pt = SplitLineIntersect.FindIntersection(entity, sl);
+                if (pt != null)
+                {
+                    crossedLine = sl;
+                    intersectionPt = pt;
+                    break;
+                }
+            }
+        }
+
+        if (crossedLine != null)
+        {
+            // Entity crosses a split line — split it and keep the half inside the region
+            var regionSide = RegionSideOf(region, crossedLine);
+            var startPt = GetStartPoint(entity);
+            var startSide = SplitLineIntersect.SideOf(startPt, crossedLine);
+            var startInRegion = startSide == regionSide || startSide == 0;
+
+            SplitEntityAtPoint(entity, intersectionPt.Value, startInRegion, crossedLine, entities, splitPoints);
+        }
+        else
+        {
+            // Entity doesn't cross any boundary split line — check if it's inside the region
+            var mid = MidPoint(entity);
+            if (region.Contains(mid))
+                entities.Add(entity);
+        }
+    }
+
+    private static void SplitEntityAtPoint(Entity entity, Vector point, bool startInRegion,
+        SplitLine crossedLine, List<Entity> entities,
+        List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints)
+    {
+        if (entity is Line line)
+        {
+            var (first, second) = line.SplitAt(point);
+            if (startInRegion)
+            {
+                if (first != null) entities.Add(first);
+                splitPoints.Add((point, crossedLine, true));
+            }
+            else
+            {
+                splitPoints.Add((point, crossedLine, false));
+                if (second != null) entities.Add(second);
+            }
+        }
+        else if (entity is Arc arc)
+        {
+            var (first, second) = arc.SplitAt(point);
+            if (startInRegion)
+            {
+                if (first != null) entities.Add(first);
+                splitPoints.Add((point, crossedLine, true));
+            }
+            else
+            {
+                splitPoints.Add((point, crossedLine, false));
+                if (second != null) entities.Add(second);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Returns split lines whose position matches a boundary edge of the region.
+    /// </summary>
+    private static List<SplitLine> GetBoundarySplitLines(Box region, List<SplitLine> splitLines)
+    {
+        var result = new List<SplitLine>();
+        foreach (var sl in splitLines)
+        {
+            if (sl.Axis == CutOffAxis.Vertical)
+            {
+                if (System.Math.Abs(sl.Position - region.Left) < OpenNest.Math.Tolerance.Epsilon
+                    || System.Math.Abs(sl.Position - region.Right) < OpenNest.Math.Tolerance.Epsilon)
+                    result.Add(sl);
+            }
+            else
+            {
+                if (System.Math.Abs(sl.Position - region.Bottom) < OpenNest.Math.Tolerance.Epsilon
+                    || System.Math.Abs(sl.Position - region.Top) < OpenNest.Math.Tolerance.Epsilon)
+                    result.Add(sl);
+            }
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Returns -1 or +1 indicating which side of the split line the region center is on.
+    /// </summary>
+    private static int RegionSideOf(Box region, SplitLine sl)
+    {
+        return SplitLineIntersect.SideOf(region.Center, sl);
+    }
+
+    /// <summary>
+    /// Returns the midpoint of an entity. For lines: average of endpoints.
+    /// For arcs: point at the mid-angle.
+    /// </summary>
+    private static Vector MidPoint(Entity entity)
+    {
+        if (entity is Line line)
+            return line.MidPoint;
+
+        if (entity is Arc arc)
+        {
+            var midAngle = (arc.StartAngle + arc.EndAngle) / 2;
+            return new Vector(
+                arc.Center.X + arc.Radius * System.Math.Cos(midAngle),
+                arc.Center.Y + arc.Radius * System.Math.Sin(midAngle));
+        }
+
+        return new Vector(0, 0);
+    }
+
+    /// <summary>
+    /// Groups split points by split line, pairs exits with entries, and generates feature edges.
+    /// </summary>
+    private static void InsertFeatureEdges(List<Entity> entities,
+        List<(Vector Point, SplitLine Line, bool IsExit)> splitPoints,
+        Box region, List<SplitLine> boundarySplitLines,
+        ISplitFeature feature, SplitParameters parameters)
+    {
+        // Group split points by their split line
+        var groups = new Dictionary<SplitLine, List<(Vector Point, bool IsExit)>>();
+        foreach (var sp in splitPoints)
+        {
+            if (!groups.ContainsKey(sp.Line))
+                groups[sp.Line] = new List<(Vector, bool)>();
+            groups[sp.Line].Add((sp.Point, sp.IsExit));
+        }
+
+        foreach (var kvp in groups)
+        {
+            var sl = kvp.Key;
+            var points = kvp.Value;
+
+            // Pair each exit with the next entry
+            var exits = points.Where(p => p.IsExit).Select(p => p.Point).ToList();
+            var entries = points.Where(p => !p.IsExit).Select(p => p.Point).ToList();
+
+            if (exits.Count == 0 || entries.Count == 0)
+                continue;
+
+            // For each exit, find the matching entry to form the feature edge span
+            // Sort exits and entries by their position along the split line
+            var isVertical = sl.Axis == CutOffAxis.Vertical;
+            exits = exits.OrderBy(p => isVertical ? p.Y : p.X).ToList();
+            entries = entries.OrderBy(p => isVertical ? p.Y : p.X).ToList();
+
+            // Pair them up: each exit with the next entry (or vice versa)
+            var pairCount = System.Math.Min(exits.Count, entries.Count);
+            for (var i = 0; i < pairCount; i++)
+            {
+                var exitPt = exits[i];
+                var entryPt = entries[i];
+
+                var extentStart = isVertical
+                    ? System.Math.Min(exitPt.Y, entryPt.Y)
+                    : System.Math.Min(exitPt.X, entryPt.X);
+                var extentEnd = isVertical
+                    ? System.Math.Max(exitPt.Y, entryPt.Y)
+                    : System.Math.Max(exitPt.X, entryPt.X);
+
+                var featureResult = feature.GenerateFeatures(sl, extentStart, extentEnd, parameters);
+
+                var isNegativeSide = RegionSideOf(region, sl) < 0;
+                var featureEdge = isNegativeSide ? featureResult.NegativeSideEdge : featureResult.PositiveSideEdge;
+
+                if (featureEdge.Count > 0)
+                    featureEdge = AlignFeatureDirection(featureEdge, exitPt, entryPt, sl.Axis);
+
+                entities.AddRange(featureEdge);
+            }
+        }
+    }
+
+    private static List<Entity> AlignFeatureDirection(List<Entity> featureEdge, Vector start, Vector end, CutOffAxis axis)
+    {
+        var featureStart = GetStartPoint(featureEdge[0]);
+        var featureEnd = GetEndPoint(featureEdge[^1]);
+        var isVertical = axis == CutOffAxis.Vertical;
+
+        var edgeGoesForward = isVertical ? start.Y < end.Y : start.X < end.X;
+        var featureGoesForward = isVertical ? featureStart.Y < featureEnd.Y : featureStart.X < featureEnd.X;
+
+        if (edgeGoesForward != featureGoesForward)
+        {
+            featureEdge = new List<Entity>(featureEdge);
+            featureEdge.Reverse();
+            foreach (var e in featureEdge)
+                e.Reverse();
+        }
+
+        return featureEdge;
+    }
+
+    private static void EnsurePerimeterWinding(List<Entity> entities)
+    {
+        var shape = new Shape();
+        shape.Entities.AddRange(entities);
+        var poly = shape.ToPolygon();
+        if (poly != null && poly.RotationDirection() != RotationType.CW)
+            shape.Reverse();
+
+        entities.Clear();
+        entities.AddRange(shape.Entities);
+    }
+
+    private static bool IsCutoutInRegion(Shape cutout, Box region)
+    {
+        if (cutout.Entities.Count == 0) return false;
+        var pt = GetStartPoint(cutout.Entities[0]);
+        return region.Contains(pt);
+    }
+
+    private static bool DoesCutoutCrossSplitLine(Shape cutout, List<SplitLine> splitLines)
+    {
+        var bb = cutout.BoundingBox;
+        foreach (var sl in splitLines)
+        {
+            if (sl.Axis == CutOffAxis.Vertical && bb.Left < sl.Position && bb.Right > sl.Position)
+                return true;
+            if (sl.Axis == CutOffAxis.Horizontal && bb.Bottom < sl.Position && bb.Top > sl.Position)
+                return true;
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Clip a cutout shape to a region by walking entities, splitting at split line
+    /// intersections, keeping portions inside the region, and closing gaps with
+    /// straight lines. No polygon clipping library needed.
+    /// </summary>
+    private static List<Entity> ClipCutoutToRegion(Shape cutout, Box region, List<SplitLine> splitLines)
+    {
+        var boundarySplitLines = GetBoundarySplitLines(region, splitLines);
+        var entities = new List<Entity>();
+        var splitPoints = new List<(Vector Point, SplitLine Line, bool IsExit)>();
+
+        foreach (var entity in cutout.Entities)
+        {
+            ProcessEntity(entity, region, boundarySplitLines, entities, splitPoints);
+        }
+
+        if (entities.Count == 0)
+            return new List<Entity>();
+
+        // Close gaps with straight lines (connect exit→entry pairs)
+        var groups = new Dictionary<SplitLine, List<(Vector Point, bool IsExit)>>();
+        foreach (var sp in splitPoints)
+        {
+            if (!groups.ContainsKey(sp.Line))
+                groups[sp.Line] = new List<(Vector, bool)>();
+            groups[sp.Line].Add((sp.Point, sp.IsExit));
+        }
+
+        foreach (var kvp in groups)
+        {
+            var sl = kvp.Key;
+            var points = kvp.Value;
+            var isVertical = sl.Axis == CutOffAxis.Vertical;
+
+            var exits = points.Where(p => p.IsExit).Select(p => p.Point)
+                .OrderBy(p => isVertical ? p.Y : p.X).ToList();
+            var entries = points.Where(p => !p.IsExit).Select(p => p.Point)
+                .OrderBy(p => isVertical ? p.Y : p.X).ToList();
+
+            var pairCount = System.Math.Min(exits.Count, entries.Count);
+            for (var i = 0; i < pairCount; i++)
+                entities.Add(new Line(exits[i], entries[i]));
+        }
+
+        // Ensure CCW winding for cutouts
+        var shape = new Shape();
+        shape.Entities.AddRange(entities);
+        var poly = shape.ToPolygon();
+        if (poly != null && poly.RotationDirection() != RotationType.CCW)
+            shape.Reverse();
+
+        return shape.Entities;
+    }
+
+    private static Vector GetStartPoint(Entity entity)
+    {
+        return entity switch
+        {
+            Line l => l.StartPoint,
+            Arc a => a.StartPoint(),
+            _ => new Vector(0, 0)
+        };
+    }
+
+    private static Vector GetEndPoint(Entity entity)
+    {
+        return entity switch
+        {
+            Line l => l.EndPoint,
+            Arc a => a.EndPoint(),
+            _ => new Vector(0, 0)
+        };
+    }
+
+    private static ISplitFeature GetFeature(SplitType type)
+    {
+        return type switch
+        {
+            SplitType.Straight => new StraightSplit(),
+            SplitType.WeldGapTabs => new WeldGapTabSplit(),
+            SplitType.SpikeGroove => new SpikeGrooveSplit(),
+            _ => new StraightSplit()
+        };
+    }
+}

OpenNest.Core/Splitting/ISplitFeature.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+public class SplitFeatureResult
+{
+    public List<Entity> NegativeSideEdge { get; }
+    public List<Entity> PositiveSideEdge { get; }
+
+    public SplitFeatureResult(List<Entity> negativeSideEdge, List<Entity> positiveSideEdge)
+    {
+        NegativeSideEdge = negativeSideEdge;
+        PositiveSideEdge = positiveSideEdge;
+    }
+}
+
+public interface ISplitFeature
+{
+    string Name { get; }
+    SplitFeatureResult GenerateFeatures(SplitLine line, double extentStart, double extentEnd, SplitParameters parameters);
+}

OpenNest.Core/Splitting/SpikeGrooveSplit.cs

@@ -0,0 +1,112 @@
+using System.Collections.Generic;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+/// <summary>
+/// Generates interlocking spike/V-groove pairs along the split edge.
+/// Spikes protrude from the positive side into the negative side.
+/// V-grooves on the negative side receive the spikes for self-alignment during welding.
+/// The weld gap (grooveDepth - spikeDepth) is the clearance at the tip when assembled.
+/// </summary>
+public class SpikeGrooveSplit : ISplitFeature
+{
+    public string Name => "Spike / V-Groove";
+
+    public SplitFeatureResult GenerateFeatures(SplitLine line, double extentStart, double extentEnd, SplitParameters parameters)
+    {
+        var extent = extentEnd - extentStart;
+        var pairCount = parameters.SpikePairCount;
+        var spikeDepth = parameters.SpikeDepth;
+        var grooveDepth = parameters.GrooveDepth;
+        var angleRad = OpenNest.Math.Angle.ToRadians(parameters.SpikeAngle / 2);
+        var spikeHalfWidth = spikeDepth * System.Math.Tan(angleRad);
+        var grooveHalfWidth = grooveDepth * System.Math.Tan(angleRad);
+
+        var isVertical = line.Axis == CutOffAxis.Vertical;
+        var pos = line.Position;
+
+        // Use custom positions if provided, otherwise place evenly with margin
+        var pairPositions = new List<double>();
+        if (line.FeaturePositions.Count > 0)
+        {
+            pairPositions.AddRange(line.FeaturePositions);
+        }
+        else if (pairCount == 1)
+        {
+            pairPositions.Add(extentStart + extent / 2);
+        }
+        else
+        {
+            var margin = extent * 0.15;
+            var usable = extent - 2 * margin;
+            for (var i = 0; i < pairCount; i++)
+                pairPositions.Add(extentStart + margin + usable * i / (pairCount - 1));
+        }
+
+        var negEntities = BuildGrooveSide(pairPositions, grooveHalfWidth, grooveDepth, extentStart, extentEnd, pos, isVertical);
+        var posEntities = BuildSpikeSide(pairPositions, spikeHalfWidth, spikeDepth, extentStart, extentEnd, pos, isVertical);
+
+        return new SplitFeatureResult(negEntities, posEntities);
+    }
+
+    private static List<Entity> BuildGrooveSide(List<double> pairPositions, double halfWidth, double depth,
+        double extentStart, double extentEnd, double pos, bool isVertical)
+    {
+        var entities = new List<Entity>();
+        var cursor = extentStart;
+
+        foreach (var center in pairPositions)
+        {
+            var grooveStart = center - halfWidth;
+            var grooveEnd = center + halfWidth;
+
+            if (grooveStart > cursor + OpenNest.Math.Tolerance.Epsilon)
+                entities.Add(MakeLine(pos, cursor, pos, grooveStart, isVertical));
+
+            entities.Add(MakeLine(pos, grooveStart, pos - depth, center, isVertical));
+            entities.Add(MakeLine(pos - depth, center, pos, grooveEnd, isVertical));
+
+            cursor = grooveEnd;
+        }
+
+        if (extentEnd > cursor + OpenNest.Math.Tolerance.Epsilon)
+            entities.Add(MakeLine(pos, cursor, pos, extentEnd, isVertical));
+
+        return entities;
+    }
+
+    private static List<Entity> BuildSpikeSide(List<double> pairPositions, double halfWidth, double depth,
+        double extentStart, double extentEnd, double pos, bool isVertical)
+    {
+        var entities = new List<Entity>();
+        var cursor = extentEnd;
+
+        for (var i = pairPositions.Count - 1; i >= 0; i--)
+        {
+            var center = pairPositions[i];
+            var spikeEnd = center + halfWidth;
+            var spikeStart = center - halfWidth;
+
+            if (cursor > spikeEnd + OpenNest.Math.Tolerance.Epsilon)
+                entities.Add(MakeLine(pos, cursor, pos, spikeEnd, isVertical));
+
+            entities.Add(MakeLine(pos, spikeEnd, pos - depth, center, isVertical));
+            entities.Add(MakeLine(pos - depth, center, pos, spikeStart, isVertical));
+
+            cursor = spikeStart;
+        }
+
+        if (cursor > extentStart + OpenNest.Math.Tolerance.Epsilon)
+            entities.Add(MakeLine(pos, cursor, pos, extentStart, isVertical));
+
+        return entities;
+    }
+
+    private static Line MakeLine(double splitAxis1, double along1, double splitAxis2, double along2, bool isVertical)
+    {
+        return isVertical
+            ? new Line(new Vector(splitAxis1, along1), new Vector(splitAxis2, along2))
+            : new Line(new Vector(along1, splitAxis1), new Vector(along2, splitAxis2));
+    }
+}

OpenNest.Core/Splitting/SplitLine.cs

@@ -0,0 +1,39 @@
+using OpenNest.Geometry;
+using System.Collections.Generic;
+
+namespace OpenNest;
+
+/// <summary>
+/// Defines a split line at a position along an axis.
+/// For Vertical, Position is the X coordinate. For Horizontal, Position is the Y coordinate.
+/// </summary>
+public class SplitLine
+{
+    public double Position { get; }
+    public CutOffAxis Axis { get; }
+
+    /// <summary>
+    /// Optional custom center positions for features (tabs/spikes) along the split line.
+    /// Values are absolute coordinates on the perpendicular axis.
+    /// When empty, feature generators use their default even spacing.
+    /// </summary>
+    public List<double> FeaturePositions { get; set; } = new();
+
+    public SplitLine(double position, CutOffAxis axis)
+    {
+        Position = position;
+        Axis = axis;
+    }
+
+    /// <summary>
+    /// Returns a Line entity at the split position spanning the given extent range.
+    /// For Vertical: line from (Position, extentStart) to (Position, extentEnd).
+    /// For Horizontal: line from (extentStart, Position) to (extentEnd, Position).
+    /// </summary>
+    public Line ToLine(double extentStart, double extentEnd)
+    {
+        return Axis == CutOffAxis.Vertical
+            ? new Line(Position, extentStart, Position, extentEnd)
+            : new Line(extentStart, Position, extentEnd, Position);
+    }
+}

OpenNest.Core/Splitting/SplitLineIntersect.cs

@@ -0,0 +1,81 @@
+using OpenNest.Geometry;
+using OpenNest.Math;
+using System.Collections.Generic;
+
+namespace OpenNest;
+
+/// <summary>
+/// Static helpers for testing entity-splitline intersections.
+/// </summary>
+public static class SplitLineIntersect
+{
+    /// <summary>
+    /// Finds the intersection point between an entity and a split line.
+    /// Returns null if no intersection or the entity doesn't straddle the split line.
+    /// </summary>
+    public static Vector? FindIntersection(Entity entity, SplitLine sl)
+    {
+        if (!CrossesSplitLine(entity, sl))
+            return null;
+
+        var bbox = entity.BoundingBox;
+        var margin = 1.0;
+
+        // Create a line at the split position spanning the entity's bbox extent (with margin)
+        Line splitLine;
+
+        if (sl.Axis == CutOffAxis.Vertical)
+            splitLine = sl.ToLine(bbox.Bottom - margin, bbox.Top + margin);
+        else
+            splitLine = sl.ToLine(bbox.Left - margin, bbox.Right + margin);
+
+        switch (entity.Type)
+        {
+            case EntityType.Line:
+                var line = (Line)entity;
+                if (Intersect.Intersects(line, splitLine, out var pt))
+                    return pt;
+                return null;
+
+            case EntityType.Arc:
+                var arc = (Arc)entity;
+                if (Intersect.Intersects(arc, splitLine, out var pts))
+                    return pts.Count > 0 ? pts[0] : null;
+                return null;
+
+            default:
+                return null;
+        }
+    }
+
+    /// <summary>
+    /// Returns true if the entity's bounding box straddles the split line,
+    /// meaning it extends to both sides of the split position (not just touching).
+    /// </summary>
+    public static bool CrossesSplitLine(Entity entity, SplitLine sl)
+    {
+        var bbox = entity.BoundingBox;
+
+        if (sl.Axis == CutOffAxis.Vertical)
+            return bbox.Left < sl.Position - Tolerance.Epsilon
+                && bbox.Right > sl.Position + Tolerance.Epsilon;
+        else
+            return bbox.Bottom < sl.Position - Tolerance.Epsilon
+                && bbox.Top > sl.Position + Tolerance.Epsilon;
+    }
+
+    /// <summary>
+    /// Returns -1 if the point is below/left of the split line,
+    /// +1 if above/right, or 0 if on the line (within tolerance).
+    /// </summary>
+    public static int SideOf(Vector pt, SplitLine sl)
+    {
+        var value = sl.Axis == CutOffAxis.Vertical ? pt.X : pt.Y;
+        var diff = value - sl.Position;
+
+        if (System.Math.Abs(diff) <= Tolerance.Epsilon)
+            return 0;
+
+        return diff < 0 ? -1 : 1;
+    }
+}

OpenNest.Core/Splitting/SplitParameters.cs

@@ -0,0 +1,35 @@
+namespace OpenNest;
+
+public enum SplitType
+{
+    Straight,
+    WeldGapTabs,
+    SpikeGroove
+}
+
+public class SplitParameters
+{
+    public SplitType Type { get; set; } = SplitType.Straight;
+
+    // Tab parameters
+    public double TabWidth { get; set; } = 1.0;
+    public double TabHeight { get; set; } = 0.125;
+    public int TabCount { get; set; } = 3;
+
+    // Spike/Groove parameters
+    public double SpikeDepth { get; set; } = 0.5;
+    public double GrooveDepth { get; set; } = 0.625;
+    public double SpikeWeldGap { get; set; } = 0.125;
+    public double SpikeAngle { get; set; } = 60.0; // degrees
+    public int SpikePairCount { get; set; } = 2;
+
+    /// <summary>
+    /// Max protrusion from the split edge (for auto-fit plate size calculation).
+    /// </summary>
+    public double FeatureOverhang => Type switch
+    {
+        SplitType.WeldGapTabs => TabHeight,
+        SplitType.SpikeGroove => System.Math.Max(SpikeDepth, GrooveDepth),
+        _ => 0
+    };
+}

OpenNest.Core/Splitting/StraightSplit.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+public class StraightSplit : ISplitFeature
+{
+    public string Name => "Straight";
+
+    public SplitFeatureResult GenerateFeatures(SplitLine line, double extentStart, double extentEnd, SplitParameters parameters)
+    {
+        var (negEdge, posEdge) = line.Axis == CutOffAxis.Vertical
+            ? (new Line(new Vector(line.Position, extentStart), new Vector(line.Position, extentEnd)),
+               new Line(new Vector(line.Position, extentEnd), new Vector(line.Position, extentStart)))
+            : (new Line(new Vector(extentStart, line.Position), new Vector(extentEnd, line.Position)),
+               new Line(new Vector(extentEnd, line.Position), new Vector(extentStart, line.Position)));
+
+        return new SplitFeatureResult(
+            new List<Entity> { negEdge },
+            new List<Entity> { posEdge });
+    }
+}

OpenNest.Core/Splitting/WeldGapTabSplit.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using OpenNest.Geometry;
+
+namespace OpenNest;
+
+/// <summary>
+/// Generates rectangular tabs on one side of the split edge (negative side).
+/// The positive side remains a straight line. Tabs act as weld-gap spacers.
+/// </summary>
+public class WeldGapTabSplit : ISplitFeature
+{
+    public string Name => "Weld-Gap Tabs";
+
+    public SplitFeatureResult GenerateFeatures(SplitLine line, double extentStart, double extentEnd, SplitParameters parameters)
+    {
+        var extent = extentEnd - extentStart;
+        var tabCount = parameters.TabCount;
+        var tabWidth = parameters.TabWidth;
+        var tabHeight = parameters.TabHeight;
+
+        // Use custom positions if provided, otherwise evenly space
+        var tabCenters = new List<double>();
+        if (line.FeaturePositions.Count > 0)
+        {
+            tabCenters.AddRange(line.FeaturePositions);
+        }
+        else
+        {
+            var spacing = extent / (tabCount + 1);
+            for (var i = 0; i < tabCount; i++)
+                tabCenters.Add(extentStart + spacing * (i + 1));
+        }
+
+        var negEntities = new List<Entity>();
+        var isVertical = line.Axis == CutOffAxis.Vertical;
+        var pos = line.Position;
+
+        // Tabs protrude toward the negative side (lower coordinate on the split axis)
+        var tabDir = -1.0;
+
+        var cursor = extentStart;
+
+        for (var i = 0; i < tabCenters.Count; i++)
+        {
+            var tabCenter = tabCenters[i];
+            var tabStart = tabCenter - tabWidth / 2;
+            var tabEnd = tabCenter + tabWidth / 2;
+
+            if (isVertical)
+            {
+                if (tabStart > cursor + OpenNest.Math.Tolerance.Epsilon)
+                    negEntities.Add(new Line(new Vector(pos, cursor), new Vector(pos, tabStart)));
+
+                negEntities.Add(new Line(new Vector(pos, tabStart), new Vector(pos + tabDir * tabHeight, tabStart)));
+                negEntities.Add(new Line(new Vector(pos + tabDir * tabHeight, tabStart), new Vector(pos + tabDir * tabHeight, tabEnd)));
+                negEntities.Add(new Line(new Vector(pos + tabDir * tabHeight, tabEnd), new Vector(pos, tabEnd)));
+            }
+            else
+            {
+                if (tabStart > cursor + OpenNest.Math.Tolerance.Epsilon)
+                    negEntities.Add(new Line(new Vector(cursor, pos), new Vector(tabStart, pos)));
+
+                negEntities.Add(new Line(new Vector(tabStart, pos), new Vector(tabStart, pos + tabDir * tabHeight)));
+                negEntities.Add(new Line(new Vector(tabStart, pos + tabDir * tabHeight), new Vector(tabEnd, pos + tabDir * tabHeight)));
+                negEntities.Add(new Line(new Vector(tabEnd, pos + tabDir * tabHeight), new Vector(tabEnd, pos)));
+            }
+
+            cursor = tabEnd;
+        }
+
+        // Final segment from last tab to extent end
+        if (isVertical)
+        {
+            if (extentEnd > cursor + OpenNest.Math.Tolerance.Epsilon)
+                negEntities.Add(new Line(new Vector(pos, cursor), new Vector(pos, extentEnd)));
+        }
+        else
+        {
+            if (extentEnd > cursor + OpenNest.Math.Tolerance.Epsilon)
+                negEntities.Add(new Line(new Vector(cursor, pos), new Vector(extentEnd, pos)));
+        }
+
+        // Positive side: plain straight line (reversed direction)
+        var posEntities = new List<Entity>();
+        if (isVertical)
+            posEntities.Add(new Line(new Vector(pos, extentEnd), new Vector(pos, extentStart)));
+        else
+            posEntities.Add(new Line(new Vector(extentEnd, pos), new Vector(extentStart, pos)));
+
+        return new SplitFeatureResult(negEntities, posEntities);
+    }
+}

OpenNest.Core/Timing.cs

@@ -1,8 +1,9 @@
-using System;
-using System.Linq;
+using OpenNest.Api;
 using OpenNest.CNC;
 using OpenNest.Converters;
 using OpenNest.Geometry;
+using System;
+using System.Linq;
 
 namespace OpenNest
 {
@@ -83,7 +84,7 @@ namespace OpenNest
                     time += TimeSpan.FromSeconds(info.TravelDistance / cutParams.RapidTravelRate);
                     break;
             }
-            
+
             time += TimeSpan.FromTicks(info.PierceCount * cutParams.PierceTime.Ticks);
 
             return time;

OpenNest.Core/Units.cs

@@ -19,7 +19,7 @@ namespace OpenNest
                 case Units.Millimeters:
                     return "mm";
 
-                default: 
+                default:
                     return string.Empty;
             }
         }
@@ -34,7 +34,7 @@ namespace OpenNest
                 case Units.Millimeters:
                     return "millimeters";
 
-                default: 
+                default:
                     return string.Empty;
             }
         }
@@ -49,7 +49,7 @@ namespace OpenNest
                 case Units.Millimeters:
                     return "sec";
 
-                default: 
+                default:
                     return string.Empty;
             }
         }

OpenNest.Engine/AngleCandidateBuilder.cs

@@ -1,97 +0,0 @@
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using OpenNest.Engine.ML;
-using OpenNest.Geometry;
-using OpenNest.Math;
-
-namespace OpenNest
-{
-    /// <summary>
-    /// Builds candidate rotation angles for single-item fill. Encapsulates the
-    /// full pipeline: base angles, narrow-area sweep, ML prediction, and
-    /// known-good pruning across fills.
-    /// </summary>
-    public class AngleCandidateBuilder
-    {
-        private readonly HashSet<double> knownGoodAngles = new();
-
-        public bool ForceFullSweep { get; set; }
-
-        public List<double> Build(NestItem item, double bestRotation, Box workArea)
-        {
-            var angles = new List<double> { bestRotation, bestRotation + Angle.HalfPI };
-
-            var testPart = new Part(item.Drawing);
-            if (!bestRotation.IsEqualTo(0))
-                testPart.Rotate(bestRotation);
-            testPart.UpdateBounds();
-
-            var partLongestSide = System.Math.Max(testPart.BoundingBox.Width, testPart.BoundingBox.Length);
-            var workAreaShortSide = System.Math.Min(workArea.Width, workArea.Length);
-            var needsSweep = workAreaShortSide < partLongestSide || ForceFullSweep;
-
-            if (needsSweep)
-            {
-                var step = Angle.ToRadians(5);
-                for (var a = 0.0; a < System.Math.PI; a += step)
-                {
-                    if (!angles.Any(existing => existing.IsEqualTo(a)))
-                        angles.Add(a);
-                }
-            }
-
-            if (!ForceFullSweep && angles.Count > 2)
-            {
-                var features = FeatureExtractor.Extract(item.Drawing);
-                if (features != null)
-                {
-                    var predicted = AnglePredictor.PredictAngles(
-                        features, workArea.Width, workArea.Length);
-
-                    if (predicted != null)
-                    {
-                        var mlAngles = new List<double>(predicted);
-
-                        if (!mlAngles.Any(a => a.IsEqualTo(bestRotation)))
-                            mlAngles.Add(bestRotation);
-                        if (!mlAngles.Any(a => a.IsEqualTo(bestRotation + Angle.HalfPI)))
-                            mlAngles.Add(bestRotation + Angle.HalfPI);
-
-                        Debug.WriteLine($"[AngleCandidateBuilder] ML: {angles.Count} angles -> {mlAngles.Count} predicted");
-                        angles = mlAngles;
-                    }
-                }
-            }
-
-            if (knownGoodAngles.Count > 0 && !ForceFullSweep)
-            {
-                var pruned = new List<double> { bestRotation, bestRotation + Angle.HalfPI };
-
-                foreach (var a in knownGoodAngles)
-                {
-                    if (!pruned.Any(existing => existing.IsEqualTo(a)))
-                        pruned.Add(a);
-                }
-
-                Debug.WriteLine($"[AngleCandidateBuilder] Pruned: {angles.Count} -> {pruned.Count} angles (known-good)");
-                return pruned;
-            }
-
-            return angles;
-        }
-
-        /// <summary>
-        /// Records angles that produced results. These are used to prune
-        /// subsequent Build() calls.
-        /// </summary>
-        public void RecordProductive(List<AngleResult> angleResults)
-        {
-            foreach (var ar in angleResults)
-            {
-                if (ar.PartCount > 0)
-                    knownGoodAngles.Add(Angle.ToRadians(ar.AngleDeg));
-            }
-        }
-    }
-}

OpenNest.Engine/BestCombination.cs

@@ -1,81 +0,0 @@
-using System;
-using OpenNest.Math;
-
-namespace OpenNest
-{
-    internal static class BestCombination
-    {
-        public static bool FindFrom2(double length1, double length2, double overallLength, out int count1, out int count2)
-        {
-            overallLength += Tolerance.Epsilon;
-
-            if (length1 > overallLength)
-            {
-                if (length2 > overallLength)
-                {
-                    count1 = 0;
-                    count2 = 0;
-                    return false;
-                }
-
-                count1 = 0;
-                count2 = (int)System.Math.Floor(overallLength / length2);
-                return true;
-            }
-
-            if (length2 > overallLength)
-            {
-                count1 = (int)System.Math.Floor(overallLength / length1);
-                count2 = 0;
-                return true;
-            }
-
-            var maxCountLength1 = (int)System.Math.Floor(overallLength / length1);
-
-            count1 = maxCountLength1;
-            count2 = 0;
-
-            var remnant = overallLength - maxCountLength1 * length1;
-
-            if (remnant.IsEqualTo(0))
-                return true;
-
-            for (int countLength1 = 0; countLength1 <= maxCountLength1; ++countLength1)
-            {
-                var remnant1 = overallLength - countLength1 * length1;
-
-                if (remnant1 >= length2)
-                {
-                    var countLength2 = (int)System.Math.Floor(remnant1 / length2);
-                    var remnant2 = remnant1 - length2 * countLength2;
-
-                    if (!(remnant2 < remnant))
-                        continue;
-
-                    count1 = countLength1;
-                    count2 = countLength2;
-
-                    if (remnant2.IsEqualTo(0))
-                        break;
-
-                    remnant = remnant2;
-                }
-                else
-                {
-                    if (!(remnant1 < remnant))
-                        continue;
-
-                    count1 = countLength1;
-                    count2 = 0;
-
-                    if (remnant1.IsEqualTo(0))
-                        break;
-
-                    remnant = remnant1;
-                }
-            }
-
-            return true;
-        }
-    }
-}

OpenNest.Engine/BestFit/BestFitFinder.cs

@@ -1,25 +1,27 @@
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
 using OpenNest.Converters;
 using OpenNest.Engine.BestFit.Tiling;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 
 namespace OpenNest.Engine.BestFit
 {
     public class BestFitFinder
     {
         private readonly IPairEvaluator _evaluator;
-        private readonly ISlideComputer _slideComputer;
+        private readonly IDistanceComputer _distanceComputer;
         private readonly BestFitFilter _filter;
 
         public BestFitFinder(double maxPlateWidth, double maxPlateHeight,
             IPairEvaluator evaluator = null, ISlideComputer slideComputer = null)
         {
             _evaluator = evaluator ?? new PairEvaluator();
-            _slideComputer = slideComputer;
+            _distanceComputer = slideComputer != null
+                ? (IDistanceComputer)new GpuDistanceComputer(slideComputer)
+                : new CpuDistanceComputer();
             var plateAspect = System.Math.Max(maxPlateWidth, maxPlateHeight) /
                               System.Math.Max(System.Math.Min(maxPlateWidth, maxPlateHeight), 0.001);
             _filter = new BestFitFilter
@@ -36,7 +38,7 @@ namespace OpenNest.Engine.BestFit
             double stepSize = 0.25,
             BestFitSortField sortBy = BestFitSortField.Area)
         {
-            var strategies = BuildStrategies(drawing);
+            var strategies = BuildStrategies(drawing, spacing);
 
             var candidateBags = new ConcurrentBag<List<PairCandidate>>();
 
@@ -75,16 +77,16 @@ namespace OpenNest.Engine.BestFit
                 .ToList();
         }
 
-        private List<IBestFitStrategy> BuildStrategies(Drawing drawing)
+        private List<IBestFitStrategy> BuildStrategies(Drawing drawing, double spacing)
         {
             var angles = GetRotationAngles(drawing);
             var strategies = new List<IBestFitStrategy>();
-            var type = 1;
+            var index = 1;
 
             foreach (var angle in angles)
             {
                 var desc = string.Format("{0:F1} deg rotated, offset slide", Angle.ToDegrees(angle));
-                strategies.Add(new RotationSlideStrategy(angle, type++, desc, _slideComputer));
+                strategies.Add(new RotationSlideStrategy(angle, index++, desc, _distanceComputer));
             }
 
             return strategies;
@@ -226,7 +228,7 @@ namespace OpenNest.Engine.BestFit
                 case BestFitSortField.ShortestSide:
                     return results.OrderBy(r => r.ShortestSide).ToList();
                 case BestFitSortField.Type:
-                    return results.OrderBy(r => r.Candidate.StrategyType)
+                    return results.OrderBy(r => r.Candidate.StrategyIndex)
                         .ThenBy(r => r.Candidate.TestNumber).ToList();
                 case BestFitSortField.OriginalSequence:
                     return results.OrderBy(r => r.Candidate.TestNumber).ToList();

OpenNest.Engine/BestFit/BestFitResult.cs

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
 using OpenNest.Geometry;
 using OpenNest.Math;
+using System.Collections.Generic;
 
 namespace OpenNest.Engine.BestFit
 {

OpenNest.Engine/BestFit/CpuDistanceComputer.cs

@@ -0,0 +1,152 @@
+using OpenNest.Geometry;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenNest.Engine.BestFit
+{
+    public class CpuDistanceComputer : IDistanceComputer
+    {
+        public double[] ComputeDistances(
+            List<Line> stationaryLines,
+            List<Line> movingTemplateLines,
+            SlideOffset[] offsets)
+        {
+            var count = offsets.Length;
+            var results = new double[count];
+
+            var allMovingVerts = ExtractUniqueVertices(movingTemplateLines);
+            var allStationaryVerts = ExtractUniqueVertices(stationaryLines);
+
+            // Pre-filter vertices per unique direction (typically 4 cardinal directions).
+            var vertexCache = new Dictionary<(double, double), (Vector[] leading, Vector[] facing)>();
+
+            foreach (var offset in offsets)
+            {
+                var key = (offset.DirX, offset.DirY);
+                if (vertexCache.ContainsKey(key))
+                    continue;
+
+                var leading = FilterVerticesByProjection(allMovingVerts, offset.DirX, offset.DirY, keepHigh: true);
+                var facing = FilterVerticesByProjection(allStationaryVerts, offset.DirX, offset.DirY, keepHigh: false);
+                vertexCache[key] = (leading, facing);
+            }
+
+            System.Threading.Tasks.Parallel.For(0, count, i =>
+            {
+                var offset = offsets[i];
+                var dirX = offset.DirX;
+                var dirY = offset.DirY;
+                var oppX = -dirX;
+                var oppY = -dirY;
+
+                var (leadingMoving, facingStationary) = vertexCache[(dirX, dirY)];
+
+                var minDist = double.MaxValue;
+
+                // Case 1: Leading moving vertices → stationary edges
+                for (var v = 0; v < leadingMoving.Length; v++)
+                {
+                    var vx = leadingMoving[v].X + offset.Dx;
+                    var vy = leadingMoving[v].Y + offset.Dy;
+
+                    for (var j = 0; j < stationaryLines.Count; j++)
+                    {
+                        var e = stationaryLines[j];
+                        var d = SpatialQuery.RayEdgeDistance(
+                            vx, vy,
+                            e.StartPoint.X, e.StartPoint.Y,
+                            e.EndPoint.X, e.EndPoint.Y,
+                            dirX, dirY);
+
+                        if (d < minDist)
+                        {
+                            minDist = d;
+                            if (d <= 0) { results[i] = 0; return; }
+                        }
+                    }
+                }
+
+                // Case 2: Facing stationary vertices → moving edges (opposite direction)
+                for (var v = 0; v < facingStationary.Length; v++)
+                {
+                    var svx = facingStationary[v].X;
+                    var svy = facingStationary[v].Y;
+
+                    for (var j = 0; j < movingTemplateLines.Count; j++)
+                    {
+                        var e = movingTemplateLines[j];
+                        var d = SpatialQuery.RayEdgeDistance(
+                            svx, svy,
+                            e.StartPoint.X + offset.Dx, e.StartPoint.Y + offset.Dy,
+                            e.EndPoint.X + offset.Dx, e.EndPoint.Y + offset.Dy,
+                            oppX, oppY);
+
+                        if (d < minDist)
+                        {
+                            minDist = d;
+                            if (d <= 0) { results[i] = 0; return; }
+                        }
+                    }
+                }
+
+                results[i] = minDist;
+            });
+
+            return results;
+        }
+
+        private static Vector[] ExtractUniqueVertices(List<Line> lines)
+        {
+            var vertices = new HashSet<Vector>();
+            for (var i = 0; i < lines.Count; i++)
+            {
+                vertices.Add(lines[i].StartPoint);
+                vertices.Add(lines[i].EndPoint);
+            }
+            return vertices.ToArray();
+        }
+
+        /// <summary>
+        /// Filters vertices by their projection onto the push direction.
+        /// keepHigh=true returns the leading half (front face, closest to target).
+        /// keepHigh=false returns the facing half (side facing the approaching part).
+        /// </summary>
+        private static Vector[] FilterVerticesByProjection(
+            Vector[] vertices, double dirX, double dirY, bool keepHigh)
+        {
+            if (vertices.Length == 0)
+                return vertices;
+
+            var projections = new double[vertices.Length];
+            var min = double.MaxValue;
+            var max = double.MinValue;
+
+            for (var i = 0; i < vertices.Length; i++)
+            {
+                projections[i] = vertices[i].X * dirX + vertices[i].Y * dirY;
+                if (projections[i] < min) min = projections[i];
+                if (projections[i] > max) max = projections[i];
+            }
+
+            var midpoint = (min + max) / 2;
+            var count = 0;
+
+            for (var i = 0; i < vertices.Length; i++)
+            {
+                if (keepHigh ? projections[i] >= midpoint : projections[i] <= midpoint)
+                    count++;
+            }
+
+            var result = new Vector[count];
+            var idx = 0;
+
+            for (var i = 0; i < vertices.Length; i++)
+            {
+                if (keepHigh ? projections[i] >= midpoint : projections[i] <= midpoint)
+                    result[idx++] = vertices[i];
+            }
+
+            return result;
+        }
+    }
+}

OpenNest.Engine/BestFit/GpuDistanceComputer.cs

@@ -0,0 +1,51 @@
+using OpenNest.Geometry;
+using System.Collections.Generic;
+
+namespace OpenNest.Engine.BestFit
+{
+    public class GpuDistanceComputer : IDistanceComputer
+    {
+        private readonly ISlideComputer _slideComputer;
+
+        public GpuDistanceComputer(ISlideComputer slideComputer)
+        {
+            _slideComputer = slideComputer;
+        }
+
+        public double[] ComputeDistances(
+            List<Line> stationaryLines,
+            List<Line> movingTemplateLines,
+            SlideOffset[] offsets)
+        {
+            var stationarySegments = SpatialQuery.FlattenLines(stationaryLines);
+            var movingSegments = SpatialQuery.FlattenLines(movingTemplateLines);
+            var count = offsets.Length;
+            var flatOffsets = new double[count * 2];
+            var directions = new int[count];
+
+            for (var i = 0; i < count; i++)
+            {
+                flatOffsets[i * 2] = offsets[i].Dx;
+                flatOffsets[i * 2 + 1] = offsets[i].Dy;
+                directions[i] = DirectionVectorToInt(offsets[i].DirX, offsets[i].DirY);
+            }
+
+            return _slideComputer.ComputeBatchMultiDir(
+                stationarySegments, stationaryLines.Count,
+                movingSegments, movingTemplateLines.Count,
+                flatOffsets, count, directions);
+        }
+
+        /// <summary>
+        /// Maps a unit direction vector to a PushDirection int for the GPU interface.
+        /// Left=0, Down=1, Right=2, Up=3.
+        /// </summary>
+        private static int DirectionVectorToInt(double dirX, double dirY)
+        {
+            if (dirX < -0.5) return (int)PushDirection.Left;
+            if (dirX > 0.5) return (int)PushDirection.Right;
+            if (dirY < -0.5) return (int)PushDirection.Down;
+            return (int)PushDirection.Up;
+        }
+    }
+}

OpenNest.Engine/BestFit/IBestFitStrategy.cs

@@ -4,7 +4,7 @@ namespace OpenNest.Engine.BestFit
 {
     public interface IBestFitStrategy
     {
-        int Type { get; }
+        int StrategyIndex { get; }
         string Description { get; }
         List<PairCandidate> GenerateCandidates(Drawing drawing, double spacing, double stepSize);
     }

OpenNest.Engine/BestFit/IDistanceComputer.cs

@@ -0,0 +1,13 @@
+using OpenNest.Geometry;
+using System.Collections.Generic;
+
+namespace OpenNest.Engine.BestFit
+{
+    public interface IDistanceComputer
+    {
+        double[] ComputeDistances(
+            List<Line> stationaryLines,
+            List<Line> movingTemplateLines,
+            SlideOffset[] offsets);
+    }
+}

OpenNest.Engine/BestFit/NfpSlideStrategy.cs

@@ -0,0 +1,179 @@
+using OpenNest.Geometry;
+using OpenNest.Math;
+using System.Collections.Generic;
+using System.IO;
+
+namespace OpenNest.Engine.BestFit
+{
+    public class NfpSlideStrategy : IBestFitStrategy
+    {
+        private static readonly string LogPath = Path.Combine(
+            System.Environment.GetFolderPath(System.Environment.SpecialFolder.Desktop),
+            "nfp-slide-debug.log");
+
+        private static readonly object LogLock = new object();
+
+        private readonly double _part2Rotation;
+        private readonly Polygon _stationaryPerimeter;
+        private readonly Polygon _stationaryHull;
+        private readonly Vector _correction;
+
+        public NfpSlideStrategy(double part2Rotation, int type, string description,
+            Polygon stationaryPerimeter, Polygon stationaryHull, Vector correction)
+        {
+            _part2Rotation = part2Rotation;
+            StrategyIndex = type;
+            Description = description;
+            _stationaryPerimeter = stationaryPerimeter;
+            _stationaryHull = stationaryHull;
+            _correction = correction;
+        }
+
+        public int StrategyIndex { get; }
+        public string Description { get; }
+
+        /// <summary>
+        /// Creates an NfpSlideStrategy by extracting polygon data from a drawing.
+        /// Returns null if the drawing has no valid perimeter.
+        /// </summary>
+        public static NfpSlideStrategy Create(Drawing drawing, double part2Rotation,
+            int type, string description, double spacing)
+        {
+            var result = PolygonHelper.ExtractPerimeterPolygon(drawing, spacing / 2);
+
+            if (result.Polygon == null)
+                return null;
+
+            var hull = ConvexHull.Compute(result.Polygon.Vertices);
+
+            Log($"=== Create: drawing={drawing.Name}, rotation={Angle.ToDegrees(part2Rotation):F1}deg ===");
+            Log($"  Perimeter: {result.Polygon.Vertices.Count} verts, bounds={FormatBounds(result.Polygon)}");
+            Log($"  Hull: {hull.Vertices.Count} verts, bounds={FormatBounds(hull)}");
+            Log($"  Correction: ({result.Correction.X:F4}, {result.Correction.Y:F4})");
+            Log($"  ProgramBBox: {drawing.Program.BoundingBox()}");
+
+            return new NfpSlideStrategy(part2Rotation, type, description,
+                result.Polygon, hull, result.Correction);
+        }
+
+        public List<PairCandidate> GenerateCandidates(Drawing drawing, double spacing, double stepSize)
+        {
+            var candidates = new List<PairCandidate>();
+
+            if (stepSize <= 0)
+                return candidates;
+
+            Log($"--- GenerateCandidates: drawing={drawing.Name}, part2Rot={Angle.ToDegrees(_part2Rotation):F1}deg, spacing={spacing}, stepSize={stepSize} ---");
+
+            // Orbiting polygon: same shape rotated to Part2's angle.
+            var orbitingPerimeter = PolygonHelper.RotatePolygon(_stationaryPerimeter, _part2Rotation, reNormalize: true);
+            var orbitingPoly = ConvexHull.Compute(orbitingPerimeter.Vertices);
+
+            Log($"  Stationary hull: {_stationaryHull.Vertices.Count} verts, bounds={FormatBounds(_stationaryHull)}");
+            Log($"  Orbiting perimeter (rotated): {orbitingPerimeter.Vertices.Count} verts, bounds={FormatBounds(orbitingPerimeter)}");
+            Log($"  Orbiting hull: {orbitingPoly.Vertices.Count} verts, bounds={FormatBounds(orbitingPoly)}");
+
+            var nfp = NoFitPolygon.ComputeConvex(_stationaryHull, orbitingPoly);
+
+            if (nfp == null || nfp.Vertices.Count < 3)
+            {
+                Log($"  NFP failed or degenerate (verts={nfp?.Vertices.Count ?? 0})");
+                return candidates;
+            }
+
+            var verts = nfp.Vertices;
+            var vertCount = nfp.IsClosed() ? verts.Count - 1 : verts.Count;
+
+            Log($"  NFP: {verts.Count} verts (closed={nfp.IsClosed()}, walking {vertCount}), bounds={FormatBounds(nfp)}");
+            Log($"  Correction: ({_correction.X:F4}, {_correction.Y:F4})");
+
+            // Log NFP vertices
+            for (var v = 0; v < vertCount; v++)
+                Log($"    NFP vert[{v}]: ({verts[v].X:F4}, {verts[v].Y:F4}) -> corrected: ({verts[v].X - _correction.X:F4}, {verts[v].Y - _correction.Y:F4})");
+
+            // Compare with what RotationSlideStrategy would produce
+            var part1 = Part.CreateAtOrigin(drawing);
+            var part2 = Part.CreateAtOrigin(drawing, _part2Rotation);
+            Log($"  Part1 (rot=0): loc=({part1.Location.X:F4}, {part1.Location.Y:F4}), bbox={part1.BoundingBox}");
+            Log($"  Part2 (rot={Angle.ToDegrees(_part2Rotation):F1}): loc=({part2.Location.X:F4}, {part2.Location.Y:F4}), bbox={part2.BoundingBox}");
+
+            var testNumber = 0;
+
+            for (var i = 0; i < vertCount; i++)
+            {
+                var offset = ApplyCorrection(verts[i], _correction);
+                candidates.Add(MakeCandidate(drawing, offset, spacing, testNumber++));
+
+                // Add edge samples for long edges.
+                var next = (i + 1) % vertCount;
+                var dx = verts[next].X - verts[i].X;
+                var dy = verts[next].Y - verts[i].Y;
+                var edgeLength = System.Math.Sqrt(dx * dx + dy * dy);
+
+                if (edgeLength > stepSize)
+                {
+                    var steps = (int)(edgeLength / stepSize);
+                    for (var s = 1; s < steps; s++)
+                    {
+                        var t = (double)s / steps;
+                        var sample = new Vector(
+                            verts[i].X + dx * t,
+                            verts[i].Y + dy * t);
+                        var sampleOffset = ApplyCorrection(sample, _correction);
+                        candidates.Add(MakeCandidate(drawing, sampleOffset, spacing, testNumber++));
+                    }
+                }
+            }
+
+            // Log overlap check for vertex candidates (first few)
+            var checkCount = System.Math.Min(vertCount, 8);
+            for (var c = 0; c < checkCount; c++)
+            {
+                var cand = candidates[c];
+                var p2 = Part.CreateAtOrigin(drawing, cand.Part2Rotation);
+                p2.Location = cand.Part2Offset;
+                var overlaps = part1.Intersects(p2, out _);
+                Log($"  Candidate[{c}]: offset=({cand.Part2Offset.X:F4}, {cand.Part2Offset.Y:F4}), overlaps={overlaps}");
+            }
+
+            Log($"  Total candidates: {candidates.Count}");
+            Log("");
+
+            return candidates;
+        }
+
+        private static Vector ApplyCorrection(Vector nfpVertex, Vector correction)
+        {
+            return new Vector(nfpVertex.X - correction.X, nfpVertex.Y - correction.Y);
+        }
+
+        private PairCandidate MakeCandidate(Drawing drawing, Vector offset, double spacing, int testNumber)
+        {
+            return new PairCandidate
+            {
+                Drawing = drawing,
+                Part1Rotation = 0,
+                Part2Rotation = _part2Rotation,
+                Part2Offset = offset,
+                StrategyIndex = StrategyIndex,
+                TestNumber = testNumber,
+                Spacing = spacing
+            };
+        }
+
+        private static string FormatBounds(Polygon polygon)
+        {
+            polygon.UpdateBounds();
+            var bb = polygon.BoundingBox;
+            return $"[({bb.Left:F4}, {bb.Bottom:F4})-({bb.Right:F4}, {bb.Top:F4}), {bb.Width:F2}x{bb.Length:F2}]";
+        }
+
+        private static void Log(string message)
+        {
+            lock (LogLock)
+            {
+                File.AppendAllText(LogPath, message + "\n");
+            }
+        }
+    }
+}