fix: Prevent shape change after material creation

Disable Shape dropdown on existing materials since changing shape would
require completely different dimension properties.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.claude/mcp/CutList.Mcp.runtimeconfig.json

@@ -0,0 +1,20 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "8.0.0"
+      },
+      {
+        "name": "Microsoft.AspNetCore.App",
+        "version": "8.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Reflection.NullabilityInfoContext.IsSupported": true,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

.claude/mcp/CutList.Web.runtimeconfig.json

@@ -0,0 +1,21 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "8.0.0"
+      },
+      {
+        "name": "Microsoft.AspNetCore.App",
+        "version": "8.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.GC.Server": true,
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Reflection.NullabilityInfoContext.IsSupported": true,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

.claude/mcp/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

.claude/mcp/appsettings.json

@@ -0,0 +1,13 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning",
+      "Microsoft.EntityFrameworkCore.Database.Command": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=CutListDb;Trusted_Connection=True;MultipleActiveResultSets=true"
+  }
+}

.claude/settings.local.json

@@ -0,0 +1,28 @@
+{
+  "permissions": {
+    "allow": [
+      "Skill(roslyn-bridge)",
+      "Bash(dotnet build:*)",
+      "SlashCommand(/rb)",
+      "mcp__roslyn-bridge__get_projects",
+      "Bash(dotnet tool install:*)",
+      "Bash(dotnet ilspy:*)",
+      "Bash(dotnet add package:*)",
+      "Bash(git -C /c/Users/AJ/Desktop/Projects/CutList add CutList.Core/BinComparer.cs CutList.Core/BinItem.cs CutList.Core/MultiBin.cs CutList/Tool.cs)",
+      "Bash(git -C /c/Users/AJ/Desktop/Projects/CutList commit --amend --no-edit)",
+      "mcp__roslyn-bridge__get_code_smells",
+      "mcp__roslyn-bridge__get_duplicates",
+      "mcp__roslyn-bridge__get_code_smell_summary",
+      "mcp__cutlist__create_cutlist",
+      "Bash(dotnet run:*)",
+      "mcp__roslyn-bridge__get_files",
+      "mcp__roslyn-bridge__refresh_workspace",
+      "mcp__roslyn-bridge__get_diagnostics",
+      "Bash(dotnet ef database update:*)",
+      "mcp__roslyn-bridge__search_symbol",
+      "Bash(dotnet ef migrations add:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

CutList.Core/BinFileSaver.cs

@@ -11,6 +11,16 @@ namespace CutList.Core
 
         public bool OpenFileAfterSave { get; set; }
 
+        /// <summary>
+        /// The cutting method/tool used (e.g., "Miter Saw", "Table Saw").
+        /// </summary>
+        public string? CutMethod { get; set; }
+
+        /// <summary>
+        /// The material shape (e.g., "Round Tube", "Square Tube", "Flat Bar").
+        /// </summary>
+        public string? MaterialShape { get; set; }
+
         public BinFileSaver(IEnumerable<Bin> bins)
         {
             _bins = bins ?? throw new ArgumentNullException(nameof(bins));
@@ -74,10 +84,24 @@ namespace CutList.Core
             var totalItems = _bins.Sum(b => b.Items.Count);
 
             writer.WriteLine("CUT LIST");
-            writer.WriteLine($"Date: {DateTime.Now:g}");
+            WriteSeparator(writer, '=');
-            writer.WriteLine($"Total stock bars needed: {totalBars}");
-            writer.WriteLine($"Total pieces to cut: {totalItems}");
             writer.WriteLine();
+            WriteAlignedLine(writer, "Date", DateTime.Now.ToString("g"));
+
+            if (!string.IsNullOrEmpty(CutMethod))
+                WriteAlignedLine(writer, "Cut Method", CutMethod);
+
+            if (!string.IsNullOrEmpty(MaterialShape))
+                WriteAlignedLine(writer, "Material", MaterialShape);
+
+            WriteAlignedLine(writer, "Stock Bars Needed", totalBars.ToString());
+            WriteAlignedLine(writer, "Total Pieces", totalItems.ToString());
+            writer.WriteLine();
+        }
+
+        private static void WriteAlignedLine(TextWriter writer, string label, string value, int labelWidth = 20)
+        {
+            writer.WriteLine($"  {label.PadRight(labelWidth)} {value}");
         }
 
         private void WriteBinSummary(TextWriter writer, Bin bin, int id)
@@ -85,8 +109,9 @@ namespace CutList.Core
             var stockLength = FormatHelper.ConvertToMixedFraction(bin.Length);
             var dropLength = FormatHelper.ConvertToMixedFraction(bin.RemainingLength);
 
-            writer.WriteLine(new string('─', 50));
+            WriteSeparator(writer);
-            writer.WriteLine($"BAR #{id}  -  Start with {stockLength}\" stock");
+
+            writer.WriteLine($"BAR #{id}  -  Length: {stockLength}\"");
             writer.WriteLine();
             writer.WriteLine("  Cut these pieces:");
 
@@ -97,6 +122,11 @@ namespace CutList.Core
             writer.WriteLine();
         }
 
+        private static void WriteSeparator(TextWriter writer, char c = '─', int length = 50)
+        {
+            writer.WriteLine(new string(c, length));
+        }
+
         private void WriteBinItems(TextWriter writer, Bin bin)
         {
             var groups = bin.Items
@@ -128,14 +158,14 @@ namespace CutList.Core
 
             string fmt(double v) => FormatHelper.ConvertToMixedFraction(v);
 
-            writer.WriteLine(new string('═', 50));
+            WriteSeparator(writer, '=');
             writer.WriteLine("SUMMARY");
-            writer.WriteLine($"  Stock bars needed: {totalBars}");
+            writer.WriteLine();
-            writer.WriteLine($"  Total pieces to cut: {totalItems}");
+            WriteAlignedLine(writer, "Stock Bars Needed", totalBars.ToString());
-            writer.WriteLine($"  Total material used: {fmt(totalStock)}\"");
+            WriteAlignedLine(writer, "Total Pieces", totalItems.ToString());
-            writer.WriteLine($"  Total drop/waste: {fmt(totalDrop)}\"");
+            WriteAlignedLine(writer, "Total Material Used", $"{fmt(totalStock)}\"");
-            writer.WriteLine(new string('═', 50));
+            WriteAlignedLine(writer, "Total Drop/Waste", $"{fmt(totalDrop)}\"");
+            WriteSeparator(writer, '=');
         }
-
     }
 }

CutList.Core/Formatting/ArchUnits.cs

@@ -28,7 +28,17 @@ namespace CutList.Core.Formatting
             var match2 = regex.Match(input);
 
             if (!match2.Success)
+            {
+                // If no unit symbols, try to parse as plain inches (e.g., "0.5" or "1/2" converted to "0.5")
+                if (!input.Contains("'") && !input.Contains("\""))
+                {
+                    if (double.TryParse(input.Trim(), out var plainInches))
+                    {
+                        return Math.Round(plainInches, 8);
+                    }
+                }
                 throw new Exception("Input is not in a valid format.");
+            }
 
             var feet = match2.Groups["Feet"];
             var inches = match2.Groups["Inches"];

CutList.Core/Formatting/FormatHelper.cs

@@ -39,6 +39,12 @@ namespace CutList.Core.Formatting
                 return wholeNumber.ToString();
             }
 
+            // If whole number is 0, just show the fraction
+            if (wholeNumber == 0)
+            {
+                return $"{numerator}/{denominator}";
+            }
+
             return $"{wholeNumber}-{numerator}/{denominator}";
         }
 

CutList.Core/Nesting/AdvancedFitEngine.cs

@@ -1,248 +1,33 @@
-using System.Data;
+using CutList.Core.Nesting.Pipeline;
 
 namespace CutList.Core.Nesting
 {
+    /// <summary>
+    /// Advanced bin packing engine using First-Fit Decreasing with optimization.
+    /// This is a stateless engine that uses a composable pipeline of steps.
+    /// </summary>
     public class AdvancedFitEngine : IEngine
     {
+        private readonly PackingPipeline _pipeline;
+
         public AdvancedFitEngine()
         {
-            Bins = new List<Bin>();
+            _pipeline = new PackingPipeline()
+                .AddStep(new FilterOversizedItemsStep())
+                .AddStep(new SortItemsDescendingStep())
+                .AddStep(new FirstFitDecreasingStep())
+                .AddStep(new OptimizationStep())
+                .AddStep(new SortBinItemsStep())
+                .AddStep(new DuplicateBinsStep())
+                .AddStep(new SortBinsByUtilizationStep());
         }
 
-        public double StockLength { get; set; }
+        /// <summary>
-
+        /// Packs items into bins using the FFD algorithm with optimization passes.
-        public double Spacing { get; set; }
+        /// </summary>
-
+        public PackResult Pack(PackingRequest request)
-        public int MaxBinCount { get; set; } = int.MaxValue;
-
-        private List<BinItem> Items { get; set; }
-
-        private List<Bin> Bins { get; set; }
-
-        public Result Pack(List<BinItem> items)
         {
-            if (StockLength <= 0)
+            return _pipeline.Execute(request);
-                throw new Exception("Stock length must be greater than 0");
-
-            Items = items.OrderByDescending(i => i.Length).ToList();
-
-            var result = new Result();
-            var itemsTooLarge = Items.Where(i => i.Length > StockLength).ToList();
-            result.AddItemsNotUsed(itemsTooLarge);
-
-            Items.RemoveAll(item => itemsTooLarge.Contains(item));
-
-            CreateBins();
-
-            var finalItemsTooLarge = Items.Where(i => i.Length > StockLength).ToList();
-            result.AddItemsNotUsed(finalItemsTooLarge);
-            result.AddBins(Bins);
-
-            foreach (var bin in result.Bins)
-            {
-                foreach (var item in bin.Items)
-                {
-                    Items.Remove(item);
-                }
-            }
-
-            result.AddItemsNotUsed(Items);
-
-            return result;
         }
-
-        private void CreateBins()
-        {
-            while (Items.Count > 0 && CanAddMoreBins())
-            {
-                var bin = new Bin(StockLength)
-                {
-                    Spacing = Spacing
-                };
-
-                FillBin(bin);
-
-                while (TryImprovePacking(bin))
-                {
-                }
-
-                bin.SortItems((a, b) =>
-                {
-                    int comparison = b.Length.CompareTo(a.Length);
-                    return comparison != 0 ? comparison : a.Length.CompareTo(b.Length);
-                });
-
-                Bins.Add(bin);
-
-                CreateDuplicateBins(bin);
-            }
-
-            Bins = Bins
-                .OrderByDescending(b => b.Utilization)
-                .ThenBy(b => b.Items.Count)
-                .ToList();
-        }
-
-        private bool CanAddMoreBins()
-        {
-            if (MaxBinCount == -1)
-                return true;
-
-            if (Bins.Count < MaxBinCount)
-                return true;
-
-            return false;
-        }
-
-        private void FillBin(Bin bin)
-        {
-            for (int i = 0; i < Items.Count; i++)
-            {
-                if (bin.RemainingLength >= Items[i].Length)
-                {
-                    bin.AddItem(Items[i]);
-                    Items.RemoveAt(i);
-                    i--;
-                }
-            }
-        }
-
-        private void CreateDuplicateBins(Bin originalBin)
-        {
-            // Count how many times the bin can be duplicated
-            int duplicateCount = GetDuplicateCount(originalBin);
-
-            for (int i = 0; i < duplicateCount; i++)
-            {
-                if (!CanAddMoreBins())
-                    break;
-
-                var newBin = new Bin(originalBin.Length)
-                {
-                    Spacing = Spacing
-                };
-
-                foreach (var item in originalBin.Items)
-                {
-                    var newItem = Items.FirstOrDefault(a => a.Length == item.Length);
-                    newBin.AddItem(newItem);
-                    Items.Remove(newItem);
-                }
-
-                Bins.Add(newBin);
-            }
-        }
-
-        private int GetDuplicateCount(Bin bin)
-        {
-            int count = int.MaxValue;
-
-            foreach (var item in bin.Items.GroupBy(i => i.Length))
-            {
-                int availableCount = Items.Count(i => i.Length == item.Key);
-                count = Math.Min(count, availableCount / item.Count());
-            }
-
-            return count;
-        }
-
-        private bool TryImprovePacking(Bin bin)
-        {
-            if (bin.Items.Count == 0)
-                return false;
-
-            if (Items.Count < 2)
-                return false;
-
-            var lengthGroups = GroupItemsByLength(bin.Items);
-
-            var shortestLengthItemAvailable = Items.Min(i => i.Length);
-
-            foreach (var group in lengthGroups)
-            {
-                var minRemainingLength = bin.RemainingLength;
-                var firstItem = group.Items.FirstOrDefault();
-                bin.RemoveItem(firstItem);
-
-                for (int i = 0; i < Items.Count; i++)
-                {
-                    var item1 = Items[i];
-
-                    if (Items[i].Length > bin.RemainingLength)
-                        continue;
-
-                    var bin2 = new Bin(bin.RemainingLength);
-                    bin2.Spacing = bin.Spacing;
-                    bin2.AddItem(item1);
-
-                    for (int j = i + 1; j < Items.Count; j++)
-                    {
-                        if (bin2.RemainingLength < shortestLengthItemAvailable)
-                            break;
-
-                        var item2 = Items[j];
-
-                        if (item2.Length > bin2.RemainingLength)
-                            continue;
-
-                        bin2.AddItem(item2);
-                    }
-
-                    if (bin2.RemainingLength < minRemainingLength)
-                    {
-                        Items.Add(firstItem);
-                        bin.AddItems(bin2.Items);
-
-                        foreach (var item in bin2.Items)
-                        {
-                            Items.Remove(item);
-                        }
-
-                        // improvement made
-                        return true;
-                    }
-                }
-
-                bin.AddItem(firstItem);
-            }
-
-            return false;
-        }
-
-        private List<LengthGroup> GroupItemsByLength(IEnumerable<BinItem> items)
-        {
-            var groups = new List<LengthGroup>();
-            var groupMap = new Dictionary<double, LengthGroup>();
-
-            foreach (var item in items)
-            {
-                if (!groupMap.TryGetValue(item.Length, out var group))
-                {
-                    group = new LengthGroup
-                    {
-                        Length = item.Length,
-                        Items = new List<BinItem>()
-                    };
-                    groupMap[item.Length] = group;
-                    groups.Add(group);
-                }
-                group.Items.Add(item);
-            }
-
-            groups.Sort((a, b) => b.Length.CompareTo(a.Length));
-            if (groups.Count > 0)
-            {
-                groups.RemoveAt(0); // Remove the largest length group
-            }
-
-            return groups;
-        }
-    }
-
-    internal class LengthGroup
-    {
-        public double Length { get; set; }
-        public List<BinItem> Items { get; set; }
     }
 }
-

CutList.Core/Nesting/BestFitEngine.cs

@@ -1,92 +1,70 @@
-using System.Data;
-
 namespace CutList.Core.Nesting
 {
+    /// <summary>
+    /// Best-Fit Decreasing bin packing engine.
+    /// Places each item in the bin with the least remaining space that can still fit it.
+    /// This is a stateless engine - all state is passed via PackingRequest.
+    /// </summary>
     public class BestFitEngine : IEngine
     {
-        public double StockLength { get; set; }
+        /// <summary>
-
+        /// Packs items into bins using the Best-Fit Decreasing algorithm.
-        public double Spacing { get; set; }
+        /// </summary>
-
+        public PackResult Pack(PackingRequest request)
-        public int MaxBinCount { get; set; } = int.MaxValue;
-
-        private List<BinItem> Items { get; set; }
-
-        public Result Pack(List<BinItem> items)
         {
-            if (StockLength <= 0)
+            var result = new PackResult();
-                throw new Exception("Stock length must be greater than 0");
+            var items = request.Items.OrderByDescending(i => i.Length).ToList();
+            var bins = new List<Bin>();
 
-            Items = items.OrderByDescending(i => i.Length).ToList();
+            // Filter oversized items
-
+            var oversizedItems = items.Where(i => i.Length > request.StockLength).ToList();
-            var result = new Result();
+            foreach (var item in oversizedItems)
-            var itemsTooLarge = Items.Where(i => i.Length > StockLength).ToList();
-            result.AddItemsNotUsed(itemsTooLarge);
-
-            foreach (var item in itemsTooLarge)
             {
-                Items.Remove(item);
+                items.Remove(item);
+                result.AddItemNotUsed(item);
             }
 
-            var bins = GetBins();
+            // Pack remaining items using best-fit
-            result.AddBins(bins);
+            foreach (var item in items)
-
-            foreach (var bin in bins)
             {
-                foreach (var item in bin.Items)
+                if (!TryFindBestBin(bins, item.Length, out var bestBin))
                 {
-                    Items.Remove(item);
+                    if (bins.Count < request.MaxBinCount)
+                    {
+                        bestBin = CreateBin(request);
+                        bins.Add(bestBin);
+                    }
+                }
+
+                if (bestBin != null)
+                {
+                    bestBin.AddItem(item);
+                }
+                else
+                {
+                    result.AddItemNotUsed(item);
                 }
             }
 
-            result.AddItemsNotUsed(Items);
+            // Sort bins by utilization
+            var sortedBins = bins
+                .OrderByDescending(b => b.Utilization)
+                .ThenBy(b => b.Items.Count);
+
+            result.AddBins(sortedBins);
 
             return result;
         }
 
-        private List<Bin> GetBins()
+        private static Bin CreateBin(PackingRequest request)
         {
-            var bins = new List<Bin>();
+            return new Bin(request.StockLength)
-
-            foreach (var item in Items)
             {
-                Bin best_bin;
+                Spacing = request.Spacing
-
-                if (!FindBin(bins.ToArray(), item.Length, out best_bin))
-                {
-                    if (item.Length > StockLength)
-                        continue;
-
-                    if (bins.Count < MaxBinCount)
-                    {
-                        best_bin = CreateBin();
-                        bins.Add(best_bin);
-                    }
-                }
-
-                if (best_bin != null)
-                    best_bin.AddItem(item);
-
-
-            }
-
-            return bins
-                .OrderByDescending(b => b.Utilization)
-                .ThenBy(b => b.Items.Count)
-                .ToList();
-        }
-
-        private Bin CreateBin()
-        {
-            var length = StockLength;
-
-            return new Bin(length)
-            {
-                Spacing = Spacing
             };
         }
 
-        private static bool FindBin(IEnumerable<Bin> bins, double length, out Bin found)
+        private static bool TryFindBestBin(IEnumerable<Bin> bins, double length, out Bin? found)
         {
             found = null;
 
@@ -95,14 +73,13 @@ namespace CutList.Core.Nesting
                 if (bin.RemainingLength < length)
                     continue;
 
-                if (found == null)
+                if (found == null || bin.RemainingLength < found.RemainingLength)
-                    found = bin;
+                {
-
-                if (bin.RemainingLength < found.RemainingLength)
                     found = bin;
+                }
             }
 
-            return (found != null);
+            return found != null;
         }
     }
-}
+}

CutList.Core/Nesting/EngineFactory.cs

@@ -1,18 +1,19 @@
 namespace CutList.Core.Nesting
 {
     /// <summary>
-    /// Default implementation of IEngineFactory that creates AdvancedFitEngine instances.
+    /// Default implementation of IEngineFactory that creates packing engines
-    /// Can be extended to support different engine types based on configuration.
+    /// based on the specified strategy.
     /// </summary>
     public class EngineFactory : IEngineFactory
     {
-        public IEngine CreateEngine(double stockLength, double spacing, int maxBinCount)
+        public IEngine CreateEngine(PackingStrategy strategy = PackingStrategy.AdvancedFit)
         {
-            return new AdvancedFitEngine
+            return strategy switch
             {
-                StockLength = stockLength,
+                PackingStrategy.AdvancedFit => new AdvancedFitEngine(),
-                Spacing = spacing,
+                PackingStrategy.BestFit => new BestFitEngine(),
-                MaxBinCount = maxBinCount
+                PackingStrategy.Exhaustive => new ExhaustiveFitEngine(),
+                _ => throw new ArgumentOutOfRangeException(nameof(strategy), strategy, "Unknown packing strategy")
             };
         }
     }

CutList.Core/Nesting/ExhaustiveFitEngine.cs

@@ -0,0 +1,198 @@
+namespace CutList.Core.Nesting
+{
+    /// <summary>
+    /// Exhaustive bin packing engine that tries all possible combinations
+    /// to find the optimal solution. Falls back to AdvancedFitEngine for
+    /// item counts exceeding the threshold due to exponential complexity.
+    /// </summary>
+    public class ExhaustiveFitEngine : IEngine
+    {
+        /// <summary>
+        /// Default maximum number of items before falling back to AdvancedFitEngine.
+        /// Testing showed 20 items is safe (~100ms worst case), while 21+ can take seconds.
+        /// </summary>
+        public const int DefaultMaxItems = 20;
+
+        private readonly IEngine _fallbackEngine;
+        private readonly int _maxItems;
+
+        public ExhaustiveFitEngine() : this(DefaultMaxItems)
+        {
+        }
+
+        /// <summary>
+        /// Creates an exhaustive engine with a custom item threshold for testing.
+        /// </summary>
+        /// <param name="maxItems">Maximum items before falling back. Use int.MaxValue to disable fallback.</param>
+        public ExhaustiveFitEngine(int maxItems)
+        {
+            _maxItems = maxItems;
+            _fallbackEngine = new AdvancedFitEngine();
+        }
+
+        public PackResult Pack(PackingRequest request)
+        {
+            // Filter oversized items first
+            var validItems = new List<BinItem>();
+            var oversizedItems = new List<BinItem>();
+
+            foreach (var item in request.Items)
+            {
+                if (item.Length > request.StockLength)
+                    oversizedItems.Add(item);
+                else
+                    validItems.Add(item);
+            }
+
+            // Fall back to AdvancedFit for large item counts
+            if (validItems.Count > _maxItems)
+            {
+                var fallbackResult = _fallbackEngine.Pack(request);
+                return fallbackResult;
+            }
+
+            // Sort items descending for better pruning
+            var sortedItems = validItems.OrderByDescending(i => i.Length).ToList();
+
+            // Find optimal solution using exhaustive search
+            var bestSolution = new SearchState
+            {
+                Bins = new List<List<BinItem>>(),
+                BinCount = int.MaxValue
+            };
+
+            var currentState = new SearchState
+            {
+                Bins = new List<List<BinItem>>(),
+                BinCount = 0
+            };
+
+            Search(sortedItems, 0, currentState, bestSolution, request);
+
+            // Build result from best solution
+            var result = new PackResult();
+            result.AddItemsNotUsed(oversizedItems);
+
+            foreach (var binItems in bestSolution.Bins)
+            {
+                var bin = new Bin(request.StockLength) { Spacing = request.Spacing };
+                foreach (var item in binItems.OrderByDescending(i => i.Length))
+                {
+                    bin.AddItem(item);
+                }
+                result.AddBin(bin);
+            }
+
+            // Sort bins by utilization
+            var sortedBins = result.Bins
+                .OrderByDescending(b => b.Utilization)
+                .ThenBy(b => b.Items.Count)
+                .ToList();
+
+            var finalResult = new PackResult();
+            finalResult.AddItemsNotUsed(oversizedItems);
+            finalResult.AddBins(sortedBins);
+
+            return finalResult;
+        }
+
+        private void Search(
+            List<BinItem> items,
+            int itemIndex,
+            SearchState current,
+            SearchState best,
+            PackingRequest request)
+        {
+            // All items placed - check if this is better
+            if (itemIndex >= items.Count)
+            {
+                if (current.BinCount < best.BinCount ||
+                    (current.BinCount == best.BinCount && GetTotalWaste(current, request) < GetTotalWaste(best, request)))
+                {
+                    best.BinCount = current.BinCount;
+                    best.Bins = current.Bins.Select(b => b.ToList()).ToList();
+                }
+                return;
+            }
+
+            // Pruning: if we already have more bins than best, stop
+            if (current.BinCount >= best.BinCount)
+                return;
+
+            // Respect max bin count
+            if (current.BinCount >= request.MaxBinCount)
+                return;
+
+            var item = items[itemIndex];
+
+            // Symmetry breaking: if this item has the same length as the previous item,
+            // only place it in bins with index >= where previous item went.
+            // This avoids redundant exploration of equivalent permutations.
+            int minBinIndex = 0;
+            if (itemIndex > 0 && items[itemIndex - 1].Length == item.Length)
+            {
+                minBinIndex = current.LastBinIndexUsed;
+            }
+
+            // Try placing in each existing bin (respecting symmetry constraint)
+            for (int i = minBinIndex; i < current.Bins.Count; i++)
+            {
+                var binUsed = GetBinUsedLength(current.Bins[i], request.Spacing);
+                var remaining = request.StockLength - binUsed;
+
+                // Item fits if adding it (with spacing) stays within tolerance
+                // Bin class allows going over by up to spacing amount
+                if (item.Length <= remaining)
+                {
+                    // Place item in this bin
+                    current.Bins[i].Add(item);
+                    var prevBinIndex = current.LastBinIndexUsed;
+                    current.LastBinIndexUsed = i;
+                    Search(items, itemIndex + 1, current, best, request);
+                    current.LastBinIndexUsed = prevBinIndex;
+                    current.Bins[i].RemoveAt(current.Bins[i].Count - 1);
+                }
+            }
+
+            // Try placing in a new bin (if allowed)
+            if (current.BinCount < request.MaxBinCount && current.BinCount < best.BinCount)
+            {
+                int newBinIndex = current.Bins.Count;
+                current.Bins.Add(new List<BinItem> { item });
+                current.BinCount++;
+                var prevBinIndex = current.LastBinIndexUsed;
+                current.LastBinIndexUsed = newBinIndex;
+                Search(items, itemIndex + 1, current, best, request);
+                current.LastBinIndexUsed = prevBinIndex;
+                current.Bins.RemoveAt(current.Bins.Count - 1);
+                current.BinCount--;
+            }
+        }
+
+        private double GetBinUsedLength(List<BinItem> binItems, double spacing)
+        {
+            if (binItems.Count == 0)
+                return 0;
+
+            return binItems.Sum(i => i.Length) + binItems.Count * spacing;
+        }
+
+        private double GetTotalWaste(SearchState state, PackingRequest request)
+        {
+            double totalWaste = 0;
+            foreach (var bin in state.Bins)
+            {
+                var used = GetBinUsedLength(bin, request.Spacing);
+                totalWaste += request.StockLength - used;
+            }
+            return totalWaste;
+        }
+
+        private class SearchState
+        {
+            public List<List<BinItem>> Bins { get; set; } = new();
+            public int BinCount { get; set; }
+            public int LastBinIndexUsed { get; set; }
+        }
+    }
+}

CutList.Core/Nesting/IEngine.cs

@@ -1,7 +1,16 @@
-namespace CutList.Core.Nesting
+namespace CutList.Core.Nesting
 {
+    /// <summary>
+    /// Interface for bin packing engines.
+    /// Engines are stateless - all configuration is passed via PackingRequest.
+    /// </summary>
     public interface IEngine
     {
-        Result Pack(List<BinItem> items);
+        /// <summary>
+        /// Packs items into bins according to the request configuration.
+        /// </summary>
+        /// <param name="request">The packing configuration and items.</param>
+        /// <returns>The packing result with bins and unused items.</returns>
+        PackResult Pack(PackingRequest request);
     }
-}
+}

CutList.Core/Nesting/IEngineFactory.cs

@@ -7,12 +7,10 @@ namespace CutList.Core.Nesting
     public interface IEngineFactory
     {
         /// <summary>
-        /// Creates a configured engine instance for bin packing.
+        /// Creates an engine instance for the specified packing strategy.
         /// </summary>
-        /// <param name="stockLength">The length of stock bins</param>
+        /// <param name="strategy">The packing strategy to use.</param>
-        /// <param name="spacing">The spacing/kerf between items</param>
+        /// <returns>A configured IEngine instance.</returns>
-        /// <param name="maxBinCount">Maximum number of bins to create</param>
+        IEngine CreateEngine(PackingStrategy strategy = PackingStrategy.AdvancedFit);
-        /// <returns>A configured IEngine instance</returns>
-        IEngine CreateEngine(double stockLength, double spacing, int maxBinCount);
     }
 }

CutList.Core/Nesting/MultiBinEngine.cs

@@ -1,8 +1,13 @@
-namespace CutList.Core.Nesting
+namespace CutList.Core.Nesting
 {
-    public class MultiBinEngine : IEngine
+    /// <summary>
+    /// Engine that coordinates packing across multiple bin types with different sizes.
+    /// Uses priority ordering to determine which bin types to fill first.
+    /// </summary>
+    public class MultiBinEngine
     {
         private readonly IEngineFactory _engineFactory;
+        private readonly List<MultiBin> _bins;
 
         public MultiBinEngine() : this(new EngineFactory())
         {
@@ -14,16 +19,14 @@
             _bins = new List<MultiBin>();
         }
 
-        private readonly List<MultiBin> _bins;
-
         /// <summary>
-        /// Gets the read-only collection of bins.
+        /// Gets the read-only collection of bin types.
         /// Use SetBins() to configure bins for packing.
         /// </summary>
         public IReadOnlyList<MultiBin> Bins => _bins.AsReadOnly();
 
         /// <summary>
-        /// Sets the bins to use for packing.
+        /// Sets the bin types to use for packing.
         /// </summary>
         public void SetBins(IEnumerable<MultiBin> bins)
         {
@@ -34,26 +37,48 @@
             }
         }
 
+        /// <summary>
+        /// The spacing/kerf between items.
+        /// </summary>
         public double Spacing { get; set; }
 
-        public Result Pack(List<BinItem> items)
+        /// <summary>
+        /// The packing strategy to use for each bin type.
+        /// </summary>
+        public PackingStrategy Strategy { get; set; } = PackingStrategy.AdvancedFit;
+
+        /// <summary>
+        /// Packs items across all configured bin types.
+        /// </summary>
+        public PackResult Pack(List<BinItem> items)
         {
-            var bins = _bins
+            var sortedBinTypes = _bins
                 .Where(b => b.Length > 0)
                 .OrderBy(b => b.Priority)
                 .ThenBy(b => b.Length)
                 .ToList();
 
-            var result = new Result();
+            var result = new PackResult();
             var remainingItems = new List<BinItem>(items);
 
-            foreach (var bin in bins)
+            var engine = _engineFactory.CreateEngine(Strategy);
-            {
-                var engine = _engineFactory.CreateEngine(bin.Length, Spacing, bin.Quantity);
-                var r = engine.Pack(remainingItems);
 
-                result.AddBins(r.Bins);
+            foreach (var binType in sortedBinTypes)
-                remainingItems = r.ItemsNotUsed.ToList();
+            {
+                if (remainingItems.Count == 0)
+                    break;
+
+                var request = new PackingRequest(
+                    items: remainingItems,
+                    stockLength: binType.Length,
+                    spacing: Spacing,
+                    maxBinCount: binType.Quantity
+                );
+
+                var packResult = engine.Pack(request);
+
+                result.AddBins(packResult.Bins);
+                remainingItems = packResult.ItemsNotUsed.ToList();
             }
 
             result.AddItemsNotUsed(remainingItems);
@@ -61,4 +86,4 @@
             return result;
         }
     }
-}
+}