@tscircuit/matchpack 0.0.4 → 0.0.6

package/dist/index.js

@@ -183,8 +183,6 @@ function visualizeInputProblem(inputProblem, basicLayout) {
         }
         return chipPin.offset;
       }
-      const groupPin = inputProblem.groupPinMap[pinId];
-      if (groupPin) return groupPin.offset;
       return null;
     }).filter(Boolean);
     for (let i = 0; i < pinPositions.length; i++) {
@@ -203,17 +201,19 @@ function visualizeInputProblem(inputProblem, basicLayout) {
         if (chip.pins.includes(pinId)) {
           const placement = basicLayout.chipPlacements[chipId];
           if (placement) {
+            const rotatedOffset = rotatePoint(
+              chipPin.offset,
+              placement.ccwRotationDegrees
+            );
             return {
-              x: placement.x + chipPin.offset.x,
-              y: placement.y + chipPin.offset.y
+              x: placement.x + rotatedOffset.x,
+              y: placement.y + rotatedOffset.y
             };
           }
         }
       }
       return chipPin.offset;
     }
-    const groupPin = inputProblem.groupPinMap[pinId];
-    if (groupPin) return groupPin.offset;
     return null;
   };
   const seenStrongConn = /* @__PURE__ */ new Set();
@@ -316,14 +316,10 @@ var ChipPartitionsSolver = class extends BaseSolver {
    */
   createPartitions(inputProblem) {
     const chipIds = Object.keys(inputProblem.chipMap);
-    const groupIds = Object.keys(inputProblem.groupMap);
     const adjacencyMap = /* @__PURE__ */ new Map();
     for (const chipId of chipIds) {
       adjacencyMap.set(chipId, /* @__PURE__ */ new Set());
     }
-    for (const groupId of groupIds) {
-      adjacencyMap.set(groupId, /* @__PURE__ */ new Set());
-    }
     for (const [connKey, isConnected] of Object.entries(
       inputProblem.pinStrongConnMap
     )) {
@@ -338,7 +334,7 @@ var ChipPartitionsSolver = class extends BaseSolver {
     }
     const visited = /* @__PURE__ */ new Set();
     const partitions = [];
-    for (const componentId of [...chipIds, ...groupIds]) {
+    for (const componentId of chipIds) {
       if (!visited.has(componentId)) {
         const partition = this.dfs(componentId, adjacencyMap, visited);
         if (partition.length > 0) {
@@ -351,7 +347,7 @@ var ChipPartitionsSolver = class extends BaseSolver {
     );
   }
   /**
-   * Finds the owner (chip or group) of a given pin
+   * Finds the owner chip of a given pin
    */
   findPinOwner(pinId, inputProblem) {
     const chipPin = inputProblem.chipPinMap[pinId];
@@ -362,14 +358,6 @@ var ChipPartitionsSolver = class extends BaseSolver {
         }
       }
     }
-    const groupPin = inputProblem.groupPinMap[pinId];
-    if (groupPin) {
-      for (const [groupId, group] of Object.entries(inputProblem.groupMap)) {
-        if (group.pins.includes(pinId)) {
-          return groupId;
-        }
-      }
-    }
     return null;
   }
   /**
@@ -396,8 +384,7 @@ var ChipPartitionsSolver = class extends BaseSolver {
    * Creates a new InputProblem containing only the components in the given partition
    */
   createInputProblemFromPartition(partition, originalProblem) {
-    const chipIds = partition.filter((id) => originalProblem.chipMap[id]);
-    const groupIds = partition.filter((id) => originalProblem.groupMap[id]);
+    const chipIds = partition;
     const relevantPinIds = /* @__PURE__ */ new Set();
     for (const chipId of chipIds) {
       const chip = originalProblem.chipMap[chipId];
@@ -405,16 +392,8 @@ var ChipPartitionsSolver = class extends BaseSolver {
         relevantPinIds.add(pinId);
       }
     }
-    for (const groupId of groupIds) {
-      const group = originalProblem.groupMap[groupId];
-      for (const pinId of group.pins) {
-        relevantPinIds.add(pinId);
-      }
-    }
     const chipMap = {};
     const chipPinMap = {};
-    const groupMap = {};
-    const groupPinMap = {};
     const netMap = {};
     const pinStrongConnMap = {};
     const netConnMap = {};
@@ -426,14 +405,6 @@ var ChipPartitionsSolver = class extends BaseSolver {
         chipPinMap[pinId] = originalProblem.chipPinMap[pinId];
       }
     }
-    for (const groupId of groupIds) {
-      groupMap[groupId] = originalProblem.groupMap[groupId];
-    }
-    for (const pinId of relevantPinIds) {
-      if (originalProblem.groupPinMap[pinId]) {
-        groupPinMap[pinId] = originalProblem.groupPinMap[pinId];
-      }
-    }
     for (const [connKey, isConnected] of Object.entries(
       originalProblem.pinStrongConnMap
     )) {
@@ -461,8 +432,6 @@ var ChipPartitionsSolver = class extends BaseSolver {
     return {
       chipMap,
       chipPinMap,
-      groupMap,
-      groupPinMap,
       netMap,
       pinStrongConnMap,
       netConnMap,
@@ -483,37 +452,237 @@ var ChipPartitionsSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/PartitionPackingSolver/PartitionPackingSolver.ts
+// lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
 import { PhasedPackSolver } from "calculate-packing";
+var SingleInnerPartitionPackingSolver = class extends BaseSolver {
+  inputProblem;
+  layout = null;
+  phasedPackSolver = null;
+  constructor(inputProblem) {
+    super();
+    this.inputProblem = inputProblem;
+  }
+  _step() {
+    try {
+      if (!this.phasedPackSolver) {
+        const packInput = this.createPackInput();
+        this.phasedPackSolver = new PhasedPackSolver(packInput);
+        this.activeSubSolver = this.phasedPackSolver;
+      }
+      this.phasedPackSolver.step();
+      if (this.phasedPackSolver.failed) {
+        this.failed = true;
+        this.error = `PhasedPackSolver failed: ${this.phasedPackSolver.error}`;
+        return;
+      }
+      if (this.phasedPackSolver.solved) {
+        this.layout = this.createLayoutFromPackingResult(
+          this.phasedPackSolver.getResult()
+        );
+        this.solved = true;
+        this.activeSubSolver = null;
+      }
+    } catch (error) {
+      this.failed = true;
+      this.error = `Failed to pack partition: ${error}`;
+    }
+  }
+  createPackInput() {
+    const pinToNetworkMap = /* @__PURE__ */ new Map();
+    for (const [connKey, connected] of Object.entries(
+      this.inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      const [pinId, netId] = connKey.split("-");
+      if (pinId && netId) {
+        pinToNetworkMap.set(pinId, netId);
+      }
+    }
+    for (const [connKey, connected] of Object.entries(
+      this.inputProblem.pinStrongConnMap
+    )) {
+      if (!connected) continue;
+      const pins = connKey.split("-");
+      if (pins.length === 2 && pins[0] && pins[1]) {
+        const existingNet = pinToNetworkMap.get(pins[0]) || pinToNetworkMap.get(pins[1]);
+        if (existingNet) {
+          pinToNetworkMap.set(pins[0], existingNet);
+          pinToNetworkMap.set(pins[1], existingNet);
+        } else {
+          pinToNetworkMap.set(pins[0], connKey);
+          pinToNetworkMap.set(pins[1], connKey);
+        }
+      }
+    }
+    const packComponents = Object.entries(this.inputProblem.chipMap).map(
+      ([chipId, chip]) => {
+        const pads = [];
+        pads.push({
+          padId: `${chipId}_body`,
+          networkId: `${chipId}_body_disconnected`,
+          type: "rect",
+          offset: { x: 0, y: 0 },
+          size: { x: chip.size.x, y: chip.size.y }
+        });
+        for (const pinId of chip.pins) {
+          const pin = this.inputProblem.chipPinMap[pinId];
+          if (!pin) continue;
+          const networkId = pinToNetworkMap.get(pinId) || `${pinId}_isolated`;
+          pads.push({
+            padId: pinId,
+            networkId,
+            type: "rect",
+            offset: { x: pin.offset.x, y: pin.offset.y },
+            size: { x: 0.1, y: 0.1 }
+            // Small size for pins
+          });
+        }
+        return {
+          componentId: chipId,
+          pads,
+          availableRotationDegrees: chip.availableRotations || [
+            0,
+            90,
+            180,
+            270
+          ]
+        };
+      }
+    );
+    return {
+      components: packComponents,
+      minGap: this.inputProblem.chipGap,
+      packOrderStrategy: "largest_to_smallest",
+      packPlacementStrategy: "minimum_sum_squared_distance_to_network"
+    };
+  }
+  createLayoutFromPackingResult(packedComponents) {
+    const chipPlacements = {};
+    for (const packedComponent of packedComponents) {
+      const chipId = packedComponent.componentId;
+      chipPlacements[chipId] = {
+        x: packedComponent.center.x,
+        y: packedComponent.center.y,
+        ccwRotationDegrees: packedComponent.ccwRotationDegrees || 0
+      };
+    }
+    return {
+      chipPlacements,
+      groupPlacements: {}
+    };
+  }
+  visualize() {
+    if (this.phasedPackSolver && !this.solved) {
+      return this.phasedPackSolver.visualize();
+    }
+    if (!this.layout) {
+      return super.visualize();
+    }
+    return visualizeInputProblem(this.inputProblem, this.layout);
+  }
+  getConstructorParams() {
+    return [this.inputProblem];
+  }
+};
+
+// lib/solvers/PackInnerPartitionsSolver/PackInnerPartitionsSolver.ts
+import { stackGraphicsHorizontally as stackGraphicsHorizontally2 } from "graphics-debug";
+var PackInnerPartitionsSolver = class extends BaseSolver {
+  partitions;
+  packedPartitions = [];
+  completedSolvers = [];
+  activeSolver = null;
+  currentPartitionIndex = 0;
+  constructor(partitions) {
+    super();
+    this.partitions = partitions;
+  }
+  _step() {
+    if (this.currentPartitionIndex >= this.partitions.length) {
+      this.solved = true;
+      return;
+    }
+    if (!this.activeSolver) {
+      const currentPartition = this.partitions[this.currentPartitionIndex];
+      this.activeSolver = new SingleInnerPartitionPackingSolver(
+        currentPartition
+      );
+      this.activeSubSolver = this.activeSolver;
+    }
+    this.activeSolver.step();
+    if (this.activeSolver.failed) {
+      this.failed = true;
+      this.error = `Partition ${this.currentPartitionIndex} failed: ${this.activeSolver.error}`;
+      return;
+    }
+    if (this.activeSolver.solved) {
+      this.completedSolvers.push(this.activeSolver);
+      if (this.activeSolver.layout) {
+        this.packedPartitions.push({
+          inputProblem: this.partitions[this.currentPartitionIndex],
+          layout: this.activeSolver.layout
+        });
+      } else {
+        this.failed = true;
+        this.error = `Partition ${this.currentPartitionIndex} completed but has no layout`;
+        return;
+      }
+      this.activeSolver = null;
+      this.activeSubSolver = null;
+      this.currentPartitionIndex++;
+    }
+  }
+  visualize() {
+    if (this.activeSolver) {
+      return this.activeSolver.visualize();
+    }
+    if (this.completedSolvers.length === 0) {
+      return super.visualize();
+    }
+    const partitionVisualizations = this.completedSolvers.map(
+      (solver) => solver.visualize()
+    );
+    const titles = this.completedSolvers.map(
+      (_, index) => `packed_partition_${index}`
+    );
+    return stackGraphicsHorizontally2(partitionVisualizations, { titles });
+  }
+  getConstructorParams() {
+    return [this.partitions];
+  }
+};
+
+// lib/solvers/PartitionPackingSolver/PartitionPackingSolver.ts
+import { PhasedPackSolver as PhasedPackSolver2 } from "calculate-packing";
 var PartitionPackingSolver = class extends BaseSolver {
-  resolvedLayout;
-  laidOutPartitions;
+  packedPartitions;
   inputProblem;
   finalLayout = null;
   phasedPackSolver = null;
   constructor(input) {
     super();
-    this.resolvedLayout = input.resolvedLayout;
-    this.laidOutPartitions = input.laidOutPartitions;
+    this.packedPartitions = input.packedPartitions;
     this.inputProblem = input.inputProblem;
   }
   _step() {
     try {
-      if (!this.resolvedLayout) {
-        this.failed = true;
-        this.error = "No resolved layout provided";
+      if (this.packedPartitions.length === 0) {
+        this.finalLayout = {
+          chipPlacements: {},
+          groupPlacements: {}
+        };
+        this.solved = true;
         return;
       }
-      const resolvedLayout = this.resolvedLayout;
-      const partitionGroups = this.organizeComponentsByPartition(resolvedLayout);
-      if (partitionGroups.length === 0) {
-        this.finalLayout = resolvedLayout;
+      if (this.packedPartitions.length === 1) {
+        this.finalLayout = this.packedPartitions[0].layout;
         this.solved = true;
         return;
       }
+      const partitionGroups = this.organizePackedPartitions();
       if (!this.phasedPackSolver) {
         const packInput = this.createPackInput(partitionGroups);
-        this.phasedPackSolver = new PhasedPackSolver(packInput);
+        this.phasedPackSolver = new PhasedPackSolver2(packInput);
         this.activeSubSolver = this.phasedPackSolver;
       }
       this.phasedPackSolver.step();
@@ -525,8 +694,7 @@ var PartitionPackingSolver = class extends BaseSolver {
       if (this.phasedPackSolver.solved) {
         const packedLayout = this.applyPackingResult(
           this.phasedPackSolver.getResult(),
-          partitionGroups,
-          resolvedLayout
+          partitionGroups
         );
         this.finalLayout = packedLayout;
         this.solved = true;
@@ -537,29 +705,37 @@ var PartitionPackingSolver = class extends BaseSolver {
       this.error = `Failed to pack partitions: ${error}`;
     }
   }
-  organizeComponentsByPartition(layout) {
+  organizePackedPartitions() {
     const partitionGroups = [];
-    for (let i = 0; i < this.laidOutPartitions.length; i++) {
-      const laidOutPartition = this.laidOutPartitions[i];
-      const partitionChipIds = [];
-      for (const chipId of Object.keys(laidOutPartition.chipMap)) {
-        if (layout.chipPlacements[chipId]) {
-          partitionChipIds.push(chipId);
-        }
-      }
+    for (let i = 0; i < this.packedPartitions.length; i++) {
+      const packedPartition = this.packedPartitions[i];
+      const partitionChipIds = Object.keys(
+        packedPartition.layout.chipPlacements
+      );
       if (partitionChipIds.length > 0) {
-        const xs = partitionChipIds.map(
-          (chipId) => layout.chipPlacements[chipId].x
-        );
-        const ys = partitionChipIds.map(
-          (chipId) => layout.chipPlacements[chipId].y
-        );
-        const bounds = {
-          minX: Math.min(...xs),
-          maxX: Math.max(...xs),
-          minY: Math.min(...ys),
-          maxY: Math.max(...ys)
-        };
+        let minX = Infinity;
+        let maxX = -Infinity;
+        let minY = Infinity;
+        let maxY = -Infinity;
+        for (const chipId of partitionChipIds) {
+          const placement = packedPartition.layout.chipPlacements[chipId];
+          const chip = packedPartition.inputProblem.chipMap[chipId];
+          let chipWidth = chip.size.x;
+          let chipHeight = chip.size.y;
+          if (placement.ccwRotationDegrees === 90 || placement.ccwRotationDegrees === 270) {
+            ;
+            [chipWidth, chipHeight] = [chipHeight, chipWidth];
+          }
+          const chipMinX = placement.x - chipWidth / 2;
+          const chipMaxX = placement.x + chipWidth / 2;
+          const chipMinY = placement.y - chipHeight / 2;
+          const chipMaxY = placement.y + chipHeight / 2;
+          minX = Math.min(minX, chipMinX);
+          maxX = Math.max(maxX, chipMaxX);
+          minY = Math.min(minY, chipMinY);
+          maxY = Math.max(maxY, chipMaxY);
+        }
+        const bounds = { minX, maxX, minY, maxY };
         partitionGroups.push({
           partitionIndex: i,
           chipIds: partitionChipIds,
@@ -570,11 +746,10 @@ var PartitionPackingSolver = class extends BaseSolver {
     return partitionGroups;
   }
   createPackInput(partitionGroups) {
-    const resolvedLayout = this.resolvedLayout;
     const pinToNetworkMap = /* @__PURE__ */ new Map();
-    for (const laidOutPartition of this.laidOutPartitions) {
+    for (const packedPartition of this.packedPartitions) {
       for (const [connKey, connected] of Object.entries(
-        laidOutPartition.netConnMap
+        packedPartition.inputProblem.netConnMap
       )) {
         if (!connected) continue;
         const [pinId, netId] = connKey.split("-");
@@ -583,7 +758,7 @@ var PartitionPackingSolver = class extends BaseSolver {
         }
       }
       for (const [connKey, connected] of Object.entries(
-        laidOutPartition.pinStrongConnMap
+        packedPartition.inputProblem.pinStrongConnMap
       )) {
         if (!connected) continue;
         const pins = connKey.split("-");
@@ -600,56 +775,64 @@ var PartitionPackingSolver = class extends BaseSolver {
       }
     }
     const packComponents = partitionGroups.map((group) => {
-      const pads = [];
-      for (const chipId of group.chipIds) {
-        const chipPlacement = resolvedLayout.chipPlacements[chipId];
-        const chip = this.laidOutPartitions[group.partitionIndex].chipMap[chipId];
-        const chipPinMap = this.laidOutPartitions[group.partitionIndex].chipPinMap;
-        const relativeChipX = chipPlacement.x - group.bounds.minX;
-        const relativeChipY = chipPlacement.y - group.bounds.minY;
-        pads.push({
-          padId: `${chipId}_body`,
-          networkId: `${chipId}_body_disconnected`,
+      const packedPartition = this.packedPartitions[group.partitionIndex];
+      const partitionWidth = group.bounds.maxX - group.bounds.minX;
+      const partitionHeight = group.bounds.maxY - group.bounds.minY;
+      const centerX = (group.bounds.minX + group.bounds.maxX) / 2;
+      const centerY = (group.bounds.minY + group.bounds.maxY) / 2;
+      const pads = [
+        {
+          padId: `partition_${group.partitionIndex}_body`,
+          networkId: `partition_${group.partitionIndex}_disconnected`,
           type: "rect",
-          offset: { x: relativeChipX, y: relativeChipY },
-          size: { x: chip.size.x, y: chip.size.y }
-        });
-        for (const pinId of chip.pins) {
-          const pin = chipPinMap[pinId];
-          if (!pin) continue;
-          const pinX = relativeChipX + pin.offset.x;
-          const pinY = relativeChipY + pin.offset.y;
-          const networkId = pinToNetworkMap.get(pinId) || pinId;
-          pads.push({
-            padId: pinId,
-            networkId,
-            type: "rect",
-            offset: { x: pinX, y: pinY },
-            size: { x: 0.2, y: 0.2 }
-            // Small size for pins
-          });
+          offset: { x: 0, y: 0 },
+          size: {
+            x: Math.max(partitionWidth, 0.1),
+            y: Math.max(partitionHeight, 0.1)
+          }
         }
-      }
-      let availableRotationDegrees = [
-        0,
-        90,
-        180,
-        270
       ];
+      const addedNetworks = /* @__PURE__ */ new Set();
+      const pinPositions = /* @__PURE__ */ new Map();
       for (const chipId of group.chipIds) {
-        const chip = this.laidOutPartitions[group.partitionIndex].chipMap[chipId];
-        const chipRotations = chip.availableRotations || [0, 90, 180, 270];
-        availableRotationDegrees = availableRotationDegrees.filter(
-          (rotation) => chipRotations.includes(rotation)
-        );
-      }
-      if (availableRotationDegrees.length === 0) {
-        availableRotationDegrees = [0];
+        const chipPlacement = packedPartition.layout.chipPlacements[chipId];
+        const chip = packedPartition.inputProblem.chipMap[chipId];
+        for (const pinId of chip.pins) {
+          const chipPin = packedPartition.inputProblem.chipPinMap[pinId];
+          if (!chipPin) continue;
+          let transformedOffset = { x: chipPin.offset.x, y: chipPin.offset.y };
+          const rotation = chipPlacement.ccwRotationDegrees || 0;
+          if (rotation === 90) {
+            transformedOffset = { x: -chipPin.offset.y, y: chipPin.offset.x };
+          } else if (rotation === 180) {
+            transformedOffset = { x: -chipPin.offset.x, y: -chipPin.offset.y };
+          } else if (rotation === 270) {
+            transformedOffset = { x: chipPin.offset.y, y: -chipPin.offset.x };
+          }
+          const absolutePinX = chipPlacement.x + transformedOffset.x;
+          const absolutePinY = chipPlacement.y + transformedOffset.y;
+          pinPositions.set(pinId, { x: absolutePinX, y: absolutePinY });
+          const networkId = pinToNetworkMap.get(pinId) || `${pinId}_disconnected`;
+          if (!addedNetworks.has(networkId)) {
+            addedNetworks.add(networkId);
+            const padOffsetX = absolutePinX - centerX;
+            const padOffsetY = absolutePinY - centerY;
+            pads.push({
+              padId: `${group.partitionIndex}_pin_${pinId}`,
+              networkId,
+              type: "rect",
+              offset: { x: padOffsetX, y: padOffsetY },
+              size: { x: 0.01, y: 0.01 }
+              // Small pin pad
+            });
+          }
+        }
       }
       return {
         componentId: `partition_${group.partitionIndex}`,
         pads,
-        availableRotationDegrees
+        availableRotationDegrees: [0]
+        // Keep partitions unrotated
       };
     });
     return {
@@ -660,7 +843,7 @@ var PartitionPackingSolver = class extends BaseSolver {
       packPlacementStrategy: "minimum_sum_squared_distance_to_network"
     };
   }
-  applyPackingResult(packedComponents, partitionGroups, currentLayout) {
+  applyPackingResult(packedComponents, partitionGroups) {
     const newChipPlacements = {};
     for (const packedComponent of packedComponents) {
       const partitionIndex = parseInt(
@@ -669,7 +852,8 @@ var PartitionPackingSolver = class extends BaseSolver {
       const group = partitionGroups.find(
         (g) => g.partitionIndex === partitionIndex
       );
-      if (group) {
+      const packedPartition = this.packedPartitions[partitionIndex];
+      if (group && packedPartition) {
         const currentCenterX = (group.bounds.minX + group.bounds.maxX) / 2;
         const currentCenterY = (group.bounds.minY + group.bounds.maxY) / 2;
         const newCenterX = packedComponent.center.x;
@@ -677,7 +861,7 @@ var PartitionPackingSolver = class extends BaseSolver {
         const offsetX = newCenterX - currentCenterX;
         const offsetY = newCenterY - currentCenterY;
         for (const chipId of group.chipIds) {
-          const originalPlacement = currentLayout.chipPlacements[chipId];
+          const originalPlacement = packedPartition.layout.chipPlacements[chipId];
           newChipPlacements[chipId] = {
             x: originalPlacement.x + offsetX,
             y: originalPlacement.y + offsetY,
@@ -688,8 +872,7 @@ var PartitionPackingSolver = class extends BaseSolver {
     }
     return {
       chipPlacements: newChipPlacements,
-      groupPlacements: { ...currentLayout.groupPlacements }
-      // Copy group placements unchanged
+      groupPlacements: {}
     };
   }
   visualize() {
@@ -701,1203 +884,113 @@ var PartitionPackingSolver = class extends BaseSolver {
     }
     const combinedProblem = {
       chipMap: {},
-      groupMap: {},
       chipPinMap: {},
-      groupPinMap: {},
       pinStrongConnMap: {},
       netMap: {},
       netConnMap: {},
       chipGap: this.inputProblem.chipGap,
       partitionGap: this.inputProblem.partitionGap
     };
-    for (const laidOutPartition of this.laidOutPartitions) {
-      Object.assign(combinedProblem.chipMap, laidOutPartition.chipMap);
-      Object.assign(combinedProblem.groupMap, laidOutPartition.groupMap);
-      Object.assign(combinedProblem.chipPinMap, laidOutPartition.chipPinMap);
-      Object.assign(combinedProblem.groupPinMap, laidOutPartition.groupPinMap);
+    for (const packedPartition of this.packedPartitions) {
+      Object.assign(
+        combinedProblem.chipMap,
+        packedPartition.inputProblem.chipMap
+      );
+      Object.assign(
+        combinedProblem.chipPinMap,
+        packedPartition.inputProblem.chipPinMap
+      );
       Object.assign(
         combinedProblem.pinStrongConnMap,
-        laidOutPartition.pinStrongConnMap
+        packedPartition.inputProblem.pinStrongConnMap
+      );
+      Object.assign(combinedProblem.netMap, packedPartition.inputProblem.netMap);
+      Object.assign(
+        combinedProblem.netConnMap,
+        packedPartition.inputProblem.netConnMap
       );
-      Object.assign(combinedProblem.netMap, laidOutPartition.netMap);
-      Object.assign(combinedProblem.netConnMap, laidOutPartition.netConnMap);
     }
     return visualizeInputProblem(combinedProblem, this.finalLayout);
   }
   getConstructorParams() {
     return {
-      resolvedLayout: this.resolvedLayout,
-      laidOutPartitions: this.laidOutPartitions,
+      packedPartitions: this.packedPartitions,
       inputProblem: this.inputProblem
     };
   }
 };
 
-// lib/solvers/PinRangeLayoutSolver/PinRangeLayoutSolver.ts
-import { stackGraphicsHorizontally as stackGraphicsHorizontally2 } from "graphics-debug";
-
-// lib/solvers/PinRangeLayoutSolver/SinglePinRangeLayoutSolver.ts
-import { pack as pack2 } from "calculate-packing";
-var SinglePinRangeLayoutSolver = class extends BaseSolver {
-  pinRange;
+// lib/solvers/LayoutPipelineSolver/LayoutPipelineSolver.ts
+function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
+  return {
+    solverName,
+    solverClass,
+    getConstructorParams,
+    onSolved: opts.onSolved
+  };
+}
+var LayoutPipelineSolver = class extends BaseSolver {
+  chipPartitionsSolver;
+  packInnerPartitionsSolver;
+  partitionPackingSolver;
+  startTimeOfPhase;
+  endTimeOfPhase;
+  timeSpentOnPhase;
+  firstIterationOfPhase;
   inputProblem;
-  layoutApplied = false;
-  layout = null;
-  constructor(pinRange, inputProblem) {
+  chipPartitions;
+  packedPartitions;
+  pipelineDef = [
+    definePipelineStep(
+      "chipPartitionsSolver",
+      ChipPartitionsSolver,
+      () => [this.inputProblem],
+      {
+        onSolved: (_layoutSolver) => {
+          this.chipPartitions = this.chipPartitionsSolver.partitions;
+        }
+      }
+    ),
+    definePipelineStep(
+      "packInnerPartitionsSolver",
+      PackInnerPartitionsSolver,
+      () => [this.chipPartitions || [this.inputProblem]],
+      {
+        onSolved: (_solver) => {
+          this.packedPartitions = this.packInnerPartitionsSolver.packedPartitions;
+        }
+      }
+    ),
+    definePipelineStep(
+      "partitionPackingSolver",
+      PartitionPackingSolver,
+      () => [
+        {
+          packedPartitions: this.packedPartitions || [],
+          inputProblem: this.inputProblem
+        }
+      ],
+      {
+        onSolved: (_solver) => {
+        }
+      }
+    )
+  ];
+  constructor(inputProblem) {
     super();
-    this.pinRange = pinRange;
     this.inputProblem = inputProblem;
+    this.MAX_ITERATIONS = 1e3;
+    this.startTimeOfPhase = {};
+    this.endTimeOfPhase = {};
+    this.timeSpentOnPhase = {};
+    this.firstIterationOfPhase = {};
   }
+  currentPipelineStepIndex = 0;
   _step() {
-    try {
-      this.layout = this.createPinRangeLayout();
-      this.layoutApplied = true;
+    const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex];
+    if (!pipelineStepDef) {
       this.solved = true;
-    } catch (error) {
-      this.failed = true;
-      this.error = `Failed to create pin range layout: ${error}`;
-    }
-  }
-  /**
-   * Build a connectivity map that normalizes network IDs by finding connected components.
-   * All pins in the same connected component get the same network ID.
-   */
-  buildNetworkConnectivityMap(relevantPins) {
-    const adjacency = /* @__PURE__ */ new Map();
-    for (const pinId of relevantPins) {
-      adjacency.set(pinId, /* @__PURE__ */ new Set());
-    }
-    for (const [connKey, connected] of Object.entries(
-      this.inputProblem.pinStrongConnMap
-    )) {
-      if (connected) {
-        const [pin1Id, pin2Id] = connKey.split("-");
-        if (pin1Id && pin2Id && relevantPins.has(pin1Id) && relevantPins.has(pin2Id)) {
-          adjacency.get(pin1Id)?.add(pin2Id);
-          adjacency.get(pin2Id)?.add(pin1Id);
-        }
-      }
-    }
-    const visited = /* @__PURE__ */ new Set();
-    const networkMap = /* @__PURE__ */ new Map();
-    const dfs = (pinId, networkId) => {
-      if (visited.has(pinId)) return;
-      visited.add(pinId);
-      networkMap.set(pinId, networkId);
-      const neighbors = adjacency.get(pinId);
-      if (neighbors) {
-        for (const neighbor of neighbors) {
-          dfs(neighbor, networkId);
-        }
-      }
-    };
-    for (const pinId of relevantPins) {
-      if (!visited.has(pinId)) {
-        const component = /* @__PURE__ */ new Set();
-        const findComponent = (id) => {
-          if (component.has(id)) return;
-          component.add(id);
-          const neighbors = adjacency.get(id);
-          if (neighbors) {
-            for (const neighbor of neighbors) {
-              findComponent(neighbor);
-            }
-          }
-        };
-        findComponent(pinId);
-        const networkId = Array.from(component).sort()[0] || pinId;
-        dfs(pinId, networkId);
-      }
-    }
-    return networkMap;
-  }
-  createPinRangeLayout() {
-    const relevantChipIds = /* @__PURE__ */ new Set();
-    for (const pinId of this.pinRange.pinIds) {
-      const chipPin = this.inputProblem.chipPinMap[pinId];
-      if (chipPin) {
-        for (const [chipId, chip] of Object.entries(
-          this.inputProblem.chipMap
-        )) {
-          if (chip.pins.includes(pinId)) {
-            relevantChipIds.add(chipId);
-            break;
-          }
-        }
-      }
-    }
-    if (this.pinRange.connectedChips) {
-      for (const chipId of this.pinRange.connectedChips) {
-        relevantChipIds.add(chipId);
-      }
-    }
-    const relevantPins = /* @__PURE__ */ new Set();
-    for (const chipId of relevantChipIds) {
-      const chip = this.inputProblem.chipMap[chipId];
-      for (const pinId of chip.pins) {
-        relevantPins.add(pinId);
-      }
-    }
-    const networkMap = this.buildNetworkConnectivityMap(relevantPins);
-    const preservedNetworks = /* @__PURE__ */ new Set();
-    const pinRangePins = new Set(this.pinRange.pinIds);
-    const connectedChips = new Set(this.pinRange.connectedChips || []);
-    let pinRangeChipId = null;
-    for (const pinId of this.pinRange.pinIds) {
-      const chipPin = this.inputProblem.chipPinMap[pinId];
-      if (chipPin) {
-        for (const [chipId, chip] of Object.entries(
-          this.inputProblem.chipMap
-        )) {
-          if (chip.pins.includes(pinId)) {
-            pinRangeChipId = chipId;
-            break;
-          }
-        }
-        if (pinRangeChipId) break;
-      }
-    }
-    const networkToPins = /* @__PURE__ */ new Map();
-    for (const [pinId, networkId] of networkMap.entries()) {
-      if (!networkToPins.has(networkId)) {
-        networkToPins.set(networkId, []);
-      }
-      networkToPins.get(networkId).push(pinId);
-    }
-    for (const [networkId, pinsInNetwork] of networkToPins.entries()) {
-      const hasPinRangePin = pinsInNetwork.some(
-        (pinId) => pinRangePins.has(pinId)
-      );
-      if (hasPinRangePin) {
-        const allPinsAllowed = pinsInNetwork.every((pinId) => {
-          if (pinRangePins.has(pinId)) return true;
-          for (const [chipId, chip] of Object.entries(
-            this.inputProblem.chipMap
-          )) {
-            if (chip.pins.includes(pinId)) {
-              return connectedChips.has(chipId);
-            }
-          }
-          return false;
-        });
-        if (allPinsAllowed) {
-          preservedNetworks.add(networkId);
-        }
-      }
-    }
-    let disconnectedCounter = 0;
-    const components = Array.from(relevantChipIds).map((chipId) => {
-      const chip = this.inputProblem.chipMap[chipId];
-      const chipPins = chip.pins.map(
-        (pinId) => this.inputProblem.chipPinMap[pinId]
-      );
-      const pads = chipPins.map((pin) => {
-        let networkId = networkMap.get(pin.pinId) || pin.pinId;
-        const isPinRangePin = pinRangePins.has(pin.pinId);
-        let pinChipId = null;
-        for (const [chipId2, chip2] of Object.entries(
-          this.inputProblem.chipMap
-        )) {
-          if (chip2.pins.includes(pin.pinId)) {
-            pinChipId = chipId2;
-            break;
-          }
-        }
-        const isConnectedChipPin = pinChipId && connectedChips.has(pinChipId);
-        let shouldPreserveNetwork = false;
-        if (isPinRangePin || isConnectedChipPin) {
-          const pinsInThisNetwork = Array.from(networkMap.entries()).filter(([, netId]) => netId === networkId).map(([pinId]) => pinId);
-          const hasPinRangePin = pinsInThisNetwork.some(
-            (pinId) => pinRangePins.has(pinId)
-          );
-          const hasConnectedChipPin = pinsInThisNetwork.some((pinId) => {
-            for (const [chipId2, chip2] of Object.entries(
-              this.inputProblem.chipMap
-            )) {
-              if (chip2.pins.includes(pinId)) {
-                return connectedChips.has(chipId2);
-              }
-            }
-            return false;
-          });
-          if (hasPinRangePin && hasConnectedChipPin && (isPinRangePin || isConnectedChipPin)) {
-            shouldPreserveNetwork = true;
-          }
-        }
-        if (!shouldPreserveNetwork) {
-          networkId = `disconnected_${disconnectedCounter++}`;
-        }
-        return {
-          padId: pin.pinId,
-          networkId,
-          type: "rect",
-          offset: pin.offset,
-          size: { x: 0.05, y: 0.05 }
-        };
-      });
-      pads.push({
-        padId: `${chipId}-body`,
-        networkId: `disconnected_${disconnectedCounter++}`,
-        type: "rect",
-        offset: { x: 0, y: 0 },
-        size: { x: chip.size.x, y: chip.size.y }
-      });
-      return {
-        componentId: chipId,
-        pads,
-        availableRotationDegrees: chip.availableRotations || [0, 90, 180, 270]
-      };
-    });
-    if (components.length === 0) {
-      return {
-        chipPlacements: {},
-        groupPlacements: {}
-      };
-    }
-    const packInput = {
-      components,
-      minGap: this.inputProblem.chipGap,
-      // Use chipGap from input problem
-      packOrderStrategy: "largest_to_smallest",
-      packPlacementStrategy: "minimum_sum_squared_distance_to_network"
-    };
-    const packResult = pack2(packInput);
-    const chipPlacements = {};
-    for (const component of packResult.components) {
-      chipPlacements[component.componentId] = {
-        x: component.center.x,
-        y: component.center.y,
-        ccwRotationDegrees: component.ccwRotationOffset
-      };
-    }
-    return {
-      chipPlacements,
-      groupPlacements: {}
-    };
-  }
-  visualize() {
-    if (!this.layoutApplied || !this.layout) {
-      return super.visualize();
-    }
-    const baseViz = visualizeInputProblem(this.inputProblem, this.layout);
-    const rangePositions = this.pinRange.pinIds.map((pinId) => {
-      const chipPin = this.inputProblem.chipPinMap[pinId];
-      const groupPin = this.inputProblem.groupPinMap[pinId];
-      const offset = chipPin?.offset || groupPin?.offset;
-      if (offset && chipPin) {
-        const chipId = Object.entries(this.inputProblem.chipMap).find(
-          ([, chip]) => chip.pins.includes(pinId)
-        )?.[0];
-        if (chipId && this.layout) {
-          const placement = this.layout.chipPlacements[chipId];
-          if (placement) {
-            const angleRad = placement.ccwRotationDegrees * Math.PI / 180;
-            const cos = Math.cos(angleRad);
-            const sin = Math.sin(angleRad);
-            const rotatedOffset = {
-              x: offset.x * cos - offset.y * sin,
-              y: offset.x * sin + offset.y * cos
-            };
-            return {
-              x: placement.x + rotatedOffset.x,
-              y: placement.y + rotatedOffset.y
-            };
-          }
-        }
-      }
-      return offset;
-    }).filter((pos) => pos !== null && pos !== void 0);
-    const highlightRects = [];
-    const connectionLines = [];
-    if (rangePositions.length > 0) {
-      const xs = rangePositions.map((p) => p.x);
-      const ys = rangePositions.map((p) => p.y);
-      const minX = Math.min(...xs) - 0.1;
-      const maxX = Math.max(...xs) + 0.1;
-      const minY = Math.min(...ys) - 0.1;
-      const maxY = Math.max(...ys) + 0.1;
-      const rangeCenterX = (minX + maxX) / 2;
-      const rangeCenterY = (minY + maxY) / 2;
-      highlightRects.push({
-        center: { x: rangeCenterX, y: rangeCenterY },
-        width: Math.max(0.2, maxX - minX),
-        height: Math.max(0.2, maxY - minY),
-        strokeColor: "blue",
-        fillColor: "rgba(0, 0, 255, 0.1)",
-        label: `Pin Range (${this.pinRange.side})`
-      });
-      if (this.pinRange.connectedChips && this.pinRange.connectedChips.length > 0 && this.layout) {
-        for (const connectedChipId of this.pinRange.connectedChips) {
-          const placement = this.layout.chipPlacements[connectedChipId];
-          const chip = this.inputProblem.chipMap[connectedChipId];
-          if (placement && chip) {
-            connectionLines.push({
-              points: [
-                { x: rangeCenterX, y: rangeCenterY },
-                { x: placement.x, y: placement.y }
-              ],
-              strokeColor: "green",
-              strokeDashArray: [5, 5]
-            });
-            highlightRects.push({
-              center: { x: placement.x, y: placement.y },
-              width: chip.size.x + 0.2,
-              height: chip.size.y + 0.2,
-              strokeColor: "green",
-              fillColor: "rgba(0, 255, 0, 0.1)",
-              strokeDashArray: [3, 3],
-              label: `Connected: ${connectedChipId}`
-            });
-          }
-        }
-      }
-    }
-    return {
-      ...baseViz,
-      rects: [...baseViz.rects || [], ...highlightRects],
-      lines: [...baseViz.lines || [], ...connectionLines]
-    };
-  }
-  getConstructorParams() {
-    return { pinRange: this.pinRange, inputProblem: this.inputProblem };
-  }
-};
-
-// lib/solvers/PinRangeLayoutSolver/PinRangeLayoutSolver.ts
-var PinRangeLayoutSolver = class extends BaseSolver {
-  pinRanges;
-  inputProblems;
-  currentRangeIndex = 0;
-  activeSolver = null;
-  completedSolvers = [];
-  constructor(pinRanges, inputProblems) {
-    super();
-    this.pinRanges = pinRanges;
-    this.inputProblems = inputProblems;
-  }
-  _step() {
-    if (this.currentRangeIndex >= this.pinRanges.length) {
-      this.solved = true;
-      return;
-    }
-    if (!this.activeSolver) {
-      const currentRange = this.pinRanges[this.currentRangeIndex];
-      const inputProblem = this.findInputProblemForRange(currentRange);
-      if (!inputProblem) {
-        this.failed = true;
-        this.error = `Could not find input problem for range ${this.currentRangeIndex}`;
-        return;
-      }
-      this.activeSolver = new SinglePinRangeLayoutSolver(
-        currentRange,
-        inputProblem
-      );
-    }
-    if (!this.activeSolver.solved && !this.activeSolver.failed) {
-      this.activeSolver.step();
-      return;
-    }
-    if (this.activeSolver.failed) {
-      this.failed = true;
-      this.error = `Pin range ${this.currentRangeIndex} failed: ${this.activeSolver.error}`;
-      return;
-    }
-    if (this.activeSolver.solved) {
-      this.completedSolvers.push(this.activeSolver);
-      this.currentRangeIndex++;
-      this.activeSolver = null;
-    }
-  }
-  findInputProblemForRange(range) {
-    for (const inputProblem of this.inputProblems) {
-      const hasAllPins = range.pinIds.every(
-        (pinId) => inputProblem.chipPinMap[pinId] || inputProblem.groupPinMap[pinId]
-      );
-      if (hasAllPins) {
-        return inputProblem;
-      }
-    }
-    return null;
-  }
-  visualize() {
-    if (this.completedSolvers.length === 0 && !this.activeSolver) {
-      return super.visualize();
-    }
-    const visualizations = [];
-    const titles = [];
-    for (let i = 0; i < this.completedSolvers.length; i++) {
-      const solver = this.completedSolvers[i];
-      visualizations.push(solver.visualize());
-      titles.push(`Range ${i} (${solver.pinRange.side})`);
-    }
-    if (this.activeSolver) {
-      visualizations.push(this.activeSolver.visualize());
-      titles.push(
-        `Range ${this.currentRangeIndex} (${this.activeSolver.pinRange.side}) - Active`
-      );
-    }
-    if (visualizations.length === 0) {
-      return super.visualize();
-    }
-    return stackGraphicsHorizontally2(visualizations, { titles });
-  }
-  getConstructorParams() {
-    return { pinRanges: this.pinRanges, inputProblems: this.inputProblems };
-  }
-};
-
-// lib/solvers/PinRangeMatchSolver/PinRangeMatchSolver.ts
-import { stackGraphicsHorizontally as stackGraphicsHorizontally3 } from "graphics-debug";
-
-// lib/solvers/PinRangeMatchSolver/PartitionPinRangeMatchSolver/PartitionPinRangeMatchSolver.ts
-var MAX_PIN_RANGE_GAP = 0.2;
-var MAX_PIN_RANGE_SIZE = 3;
-var PartitionPinRangeMatchSolver = class extends BaseSolver {
-  inputProblem;
-  pinRanges = [];
-  constructor(inputProblem) {
-    super();
-    this.inputProblem = inputProblem;
-  }
-  _step() {
-    this.pinRanges = this.createPinRanges();
-    this.solved = true;
-  }
-  createPinRanges() {
-    const pinRanges = [];
-    const passiveChips = /* @__PURE__ */ new Set();
-    for (const [chipId, chip] of Object.entries(this.inputProblem.chipMap)) {
-      if (chip.pins.length === 2) {
-        let connectedToLargerChip = false;
-        for (const pinId of chip.pins) {
-          for (const [connKey, connected] of Object.entries(
-            this.inputProblem.pinStrongConnMap
-          )) {
-            if (!connected) continue;
-            const [pin1Id, pin2Id] = connKey.split("-");
-            let connectedPinId = null;
-            if (pin1Id === pinId) {
-              connectedPinId = pin2Id;
-            } else if (pin2Id === pinId) {
-              connectedPinId = pin1Id;
-            }
-            if (connectedPinId) {
-              for (const [, otherChip] of Object.entries(
-                this.inputProblem.chipMap
-              )) {
-                if (otherChip.pins.includes(connectedPinId) && otherChip.pins.length > 2) {
-                  connectedToLargerChip = true;
-                  break;
-                }
-              }
-            }
-            if (connectedToLargerChip) break;
-          }
-          if (connectedToLargerChip) break;
-        }
-        if (connectedToLargerChip) {
-          passiveChips.add(chipId);
-        }
-      }
-    }
-    for (const [chipId, chip] of Object.entries(this.inputProblem.chipMap)) {
-      if (!passiveChips.has(chipId)) {
-        const chipPinRanges = this.createPinRangesForChip(chipId, chip.pins);
-        pinRanges.push(...chipPinRanges);
-      }
-    }
-    for (const [groupId, group] of Object.entries(this.inputProblem.groupMap)) {
-      const groupPinRanges = this.createPinRangesForGroup(groupId, group.pins);
-      pinRanges.push(...groupPinRanges);
-    }
-    for (const range of pinRanges) {
-      const connectedInfo = this.findConnectedPassives(
-        range.pinIds,
-        passiveChips
-      );
-      range.connectedPins = connectedInfo.connectedPins;
-      range.connectedChips = connectedInfo.connectedChips;
-    }
-    return pinRanges;
-  }
-  createPinRangesForChip(chipId, pinIds) {
-    const pinsBySide = /* @__PURE__ */ new Map();
-    for (const pinId of pinIds) {
-      const chipPin = this.inputProblem.chipPinMap[pinId];
-      if (!chipPin) continue;
-      if (!pinsBySide.has(chipPin.side)) {
-        pinsBySide.set(chipPin.side, []);
-      }
-      pinsBySide.get(chipPin.side).push({ pinId, offset: chipPin.offset });
-    }
-    const pinRanges = [];
-    for (const [side, pins] of pinsBySide.entries()) {
-      const ranges = this.createPinRangesForSide(side, pins, chipId);
-      pinRanges.push(...ranges);
-    }
-    return pinRanges;
-  }
-  createPinRangesForGroup(groupId, pinIds) {
-    const pinsWithOffsets = pinIds.map((pinId) => {
-      const groupPin = this.inputProblem.groupPinMap[pinId];
-      return groupPin ? { pinId, offset: groupPin.offset } : null;
-    }).filter((pin) => pin !== null && pin.offset !== void 0);
-    if (pinsWithOffsets.length === 0) return [];
-    const side = "x+";
-    return this.createPinRangesForSide(
-      side,
-      pinsWithOffsets,
-      void 0,
-      groupId
-    );
-  }
-  createPinRangesForSide(side, pins, chipId, groupId) {
-    if (pins.length === 0) return [];
-    const sortedPins = this.sortPinsBySide(pins, side);
-    const pinRanges = [];
-    let currentRange = [];
-    for (let i = 0; i < sortedPins.length; i++) {
-      const pin = sortedPins[i];
-      if (currentRange.length === 0) {
-        currentRange = [pin.pinId];
-      } else if (currentRange.length < MAX_PIN_RANGE_SIZE) {
-        const prevPin = sortedPins[i - 1];
-        const distance = this.calculateDistance(prevPin.offset, pin.offset);
-        if (distance <= MAX_PIN_RANGE_GAP) {
-          currentRange.push(pin.pinId);
-        } else {
-          pinRanges.push({
-            pinIds: [...currentRange],
-            side,
-            chipId,
-            groupId
-          });
-          currentRange = [pin.pinId];
-        }
-      } else {
-        pinRanges.push({
-          pinIds: [...currentRange],
-          side,
-          chipId,
-          groupId
-        });
-        currentRange = [pin.pinId];
-      }
-    }
-    if (currentRange.length > 0) {
-      pinRanges.push({
-        pinIds: [...currentRange],
-        side,
-        chipId,
-        groupId
-      });
-    }
-    return pinRanges;
-  }
-  sortPinsBySide(pins, side) {
-    return pins.sort((a, b) => {
-      switch (side) {
-        case "x-":
-        case "x+":
-          return a.offset.y - b.offset.y;
-        case "y-":
-        case "y+":
-          return a.offset.x - b.offset.x;
-        default:
-          return 0;
-      }
-    });
-  }
-  calculateDistance(p1, p2) {
-    return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
-  }
-  findConnectedPassives(rangePinIds, passiveChips) {
-    const connectedPins = [];
-    const connectedChips = [];
-    for (const rangePinId of rangePinIds) {
-      for (const [connKey, connected] of Object.entries(
-        this.inputProblem.pinStrongConnMap
-      )) {
-        if (!connected) continue;
-        const [pin1Id, pin2Id] = connKey.split("-");
-        let connectedPinId = null;
-        if (pin1Id === rangePinId) {
-          connectedPinId = pin2Id;
-        } else if (pin2Id === rangePinId) {
-          connectedPinId = pin1Id;
-        }
-        if (connectedPinId) {
-          for (const [chipId, chip] of Object.entries(
-            this.inputProblem.chipMap
-          )) {
-            if (chip.pins.includes(connectedPinId) && passiveChips.has(chipId)) {
-              if (!connectedChips.includes(chipId)) {
-                connectedChips.push(chipId);
-                connectedPins.push(
-                  ...chip.pins.filter(
-                    (pinId) => !connectedPins.includes(pinId)
-                  )
-                );
-              }
-              break;
-            }
-          }
-        }
-      }
-    }
-    return { connectedPins, connectedChips };
-  }
-  visualize() {
-    return {
-      lines: [],
-      points: this.pinRanges.flatMap((range) => {
-        const rangePinPoints = range.pinIds.map((pinId) => {
-          const chipPin = this.inputProblem.chipPinMap[pinId];
-          const groupPin = this.inputProblem.groupPinMap[pinId];
-          const offset = chipPin?.offset || groupPin?.offset;
-          return offset ? { x: offset.x, y: offset.y, color: "blue" } : null;
-        }).filter(
-          (point) => point !== null
-        );
-        const connectedPinPoints = (range.connectedPins || []).map((pinId) => {
-          const chipPin = this.inputProblem.chipPinMap[pinId];
-          const groupPin = this.inputProblem.groupPinMap[pinId];
-          const offset = chipPin?.offset || groupPin?.offset;
-          return offset ? { x: offset.x, y: offset.y, color: "orange" } : null;
-        }).filter(
-          (point) => point !== null
-        );
-        return [...rangePinPoints, ...connectedPinPoints];
-      }),
-      rects: [],
-      circles: []
-    };
-  }
-  getConstructorParams() {
-    return { inputProblem: this.inputProblem };
-  }
-};
-
-// lib/solvers/PinRangeMatchSolver/PinRangeMatchSolver.ts
-var PinRangeMatchSolver = class extends BaseSolver {
-  partitions;
-  currentPartitionIndex = 0;
-  activeSubSolver = null;
-  partitionResults = [];
-  constructor(partitions) {
-    super();
-    this.partitions = partitions;
-  }
-  _step() {
-    if (this.currentPartitionIndex >= this.partitions.length) {
-      this.solved = true;
-      return;
-    }
-    if (!this.activeSubSolver) {
-      const currentPartition = this.partitions[this.currentPartitionIndex];
-      this.activeSubSolver = new PartitionPinRangeMatchSolver(currentPartition);
-    }
-    if (!this.activeSubSolver.solved && !this.activeSubSolver.failed) {
-      this.activeSubSolver.step();
-      return;
-    }
-    if (this.activeSubSolver.failed) {
-      this.failed = true;
-      this.error = `Partition ${this.currentPartitionIndex} failed: ${this.activeSubSolver.error}`;
-      return;
-    }
-    if (this.activeSubSolver.solved) {
-      this.partitionResults.push(this.activeSubSolver.pinRanges);
-      this.currentPartitionIndex++;
-      this.activeSubSolver = null;
-    }
-  }
-  getAllPinRanges() {
-    return this.partitionResults.flat();
-  }
-  visualize() {
-    if (this.activeSubSolver && !this.activeSubSolver.solved) {
-      return this.activeSubSolver.visualize();
-    }
-    if (this.partitions.length === 0) {
-      return super.visualize();
-    }
-    const partitionVisualizations = this.partitions.map(
-      (partition, partitionIndex) => {
-        const basicLayout = doBasicInputProblemLayout(partition);
-        const baseViz = visualizeInputProblem(partition, basicLayout);
-        const partitionRanges = this.partitionResults[partitionIndex] || [];
-        const highlightRects = [];
-        const connectionLines = [];
-        for (const [rangeIndex, range] of partitionRanges.entries()) {
-          const rangePositions = range.pinIds.map((pinId) => {
-            const chipPin = partition.chipPinMap[pinId];
-            const groupPin = partition.groupPinMap[pinId];
-            const offset = chipPin?.offset || groupPin?.offset;
-            if (offset && chipPin) {
-              const chipId = Object.entries(partition.chipMap).find(
-                ([, chip]) => chip.pins.includes(pinId)
-              )?.[0];
-              if (chipId) {
-                const placement = basicLayout.chipPlacements[chipId];
-                if (placement) {
-                  const angleRad = placement.ccwRotationDegrees * Math.PI / 180;
-                  const cos = Math.cos(angleRad);
-                  const sin = Math.sin(angleRad);
-                  const rotatedOffset = {
-                    x: offset.x * cos - offset.y * sin,
-                    y: offset.x * sin + offset.y * cos
-                  };
-                  return {
-                    x: placement.x + rotatedOffset.x,
-                    y: placement.y + rotatedOffset.y
-                  };
-                }
-              }
-            }
-            return offset;
-          }).filter((pos) => pos !== null && pos !== void 0);
-          const rangeColor = `hsl(${rangeIndex * 60 % 360}, 70%, 50%)`;
-          let rangeCenterX = 0;
-          let rangeCenterY = 0;
-          if (rangePositions.length > 0) {
-            const xs = rangePositions.map((p) => p.x);
-            const ys = rangePositions.map((p) => p.y);
-            const minX = Math.min(...xs) - 0.05;
-            const maxX = Math.max(...xs) + 0.05;
-            const minY = Math.min(...ys) - 0.05;
-            const maxY = Math.max(...ys) + 0.05;
-            rangeCenterX = (minX + maxX) / 2;
-            rangeCenterY = (minY + maxY) / 2;
-            highlightRects.push({
-              center: { x: rangeCenterX, y: rangeCenterY },
-              width: Math.max(0.1, maxX - minX),
-              height: Math.max(0.1, maxY - minY),
-              strokeColor: rangeColor,
-              fillColor: `hsla(${rangeIndex * 60 % 360}, 70%, 50%, 0.1)`,
-              label: `Range ${rangeIndex} (${range.side})`
-            });
-          }
-          if (range.connectedChips && range.connectedChips.length > 0) {
-            const connectedPinRangeName = `Range ${rangeIndex} (${range.side})`;
-            for (const connectedChipId of range.connectedChips) {
-              const placement = basicLayout.chipPlacements[connectedChipId];
-              const chip = partition.chipMap[connectedChipId];
-              if (placement && rangePositions.length > 0 && chip) {
-                connectionLines.push({
-                  points: [
-                    { x: rangeCenterX, y: rangeCenterY },
-                    { x: placement.x, y: placement.y }
-                  ],
-                  strokeColor: rangeColor,
-                  strokeDashArray: [5, 5]
-                });
-                highlightRects.push({
-                  center: { x: placement.x, y: placement.y },
-                  width: chip.size.x + 0.1,
-                  height: chip.size.y + 0.1,
-                  strokeColor: rangeColor,
-                  fillColor: `hsla(${rangeIndex * 60 % 360}, 70%, 50%, 0.05)`,
-                  strokeDashArray: [3, 3],
-                  label: `${connectedChipId}
-${connectedPinRangeName}`
-                });
-              }
-            }
-          }
-        }
-        return {
-          ...baseViz,
-          rects: [...baseViz.rects || [], ...highlightRects],
-          lines: [...baseViz.lines || [], ...connectionLines]
-        };
-      }
-    );
-    const titles = this.partitions.map((_, index) => {
-      const ranges = this.partitionResults[index] || [];
-      const rangeCount = ranges.length;
-      const connectedCount = ranges.reduce(
-        (sum, range) => sum + (range.connectedChips?.length || 0),
-        0
-      );
-      return `Partition ${index} (${rangeCount} ranges, ${connectedCount} passives)`;
-    });
-    return stackGraphicsHorizontally3(partitionVisualizations, { titles });
-  }
-  getConstructorParams() {
-    return { partitions: this.partitions };
-  }
-};
-
-// lib/solvers/PinRangeOverlapSolver/PinRangeOverlapSolver.ts
-import { stackGraphicsHorizontally as stackGraphicsHorizontally4 } from "graphics-debug";
-var PinRangeOverlapSolver = class extends BaseSolver {
-  pinRangeLayoutSolver = null;
-  inputProblems;
-  resolvedLayout = null;
-  constructor(pinRangeLayoutSolver, inputProblems) {
-    super();
-    this.pinRangeLayoutSolver = pinRangeLayoutSolver;
-    this.inputProblems = inputProblems;
-  }
-  _step() {
-    try {
-      if (!this.pinRangeLayoutSolver?.solved) {
-        this.failed = true;
-        this.error = "PinRangeLayoutSolver not solved";
-        return;
-      }
-      const partitionLayouts = this.groupPlacementsByPartition();
-      const resolvedPartitionLayouts = partitionLayouts.map(
-        (partitionLayout) => this.resolvePartitionOverlaps(partitionLayout)
-      );
-      const finalLayout = this.positionPartitionsHorizontally(
-        resolvedPartitionLayouts
-      );
-      this.resolvedLayout = finalLayout;
-      this.solved = true;
-    } catch (error) {
-      this.failed = true;
-      this.error = `Failed to resolve pin range overlaps: ${error}`;
-    }
-  }
-  groupPlacementsByPartition() {
-    const partitionLayouts = [];
-    for (let i = 0; i < this.inputProblems.length; i++) {
-      partitionLayouts.push({
-        partitionIndex: i,
-        inputProblem: this.inputProblems[i],
-        chipPlacements: {},
-        groupPlacements: {}
-      });
-    }
-    for (const singleSolver of this.pinRangeLayoutSolver.completedSolvers) {
-      if (singleSolver.layout) {
-        const partitionIndex = this.findPartitionIndexForSolver(singleSolver);
-        if (partitionIndex >= 0) {
-          Object.assign(
-            partitionLayouts[partitionIndex].chipPlacements,
-            singleSolver.layout.chipPlacements
-          );
-          Object.assign(
-            partitionLayouts[partitionIndex].groupPlacements,
-            singleSolver.layout.groupPlacements
-          );
-        }
-      }
-    }
-    if (this.pinRangeLayoutSolver.activeSolver?.layout) {
-      const partitionIndex = this.findPartitionIndexForSolver(
-        this.pinRangeLayoutSolver.activeSolver
-      );
-      if (partitionIndex >= 0) {
-        Object.assign(
-          partitionLayouts[partitionIndex].chipPlacements,
-          this.pinRangeLayoutSolver.activeSolver.layout.chipPlacements
-        );
-        Object.assign(
-          partitionLayouts[partitionIndex].groupPlacements,
-          this.pinRangeLayoutSolver.activeSolver.layout.groupPlacements
-        );
-      }
-    }
-    return partitionLayouts;
-  }
-  findPartitionIndexForSolver(singleSolver) {
-    if (!singleSolver.layout) return -1;
-    const layoutChipIds = Object.keys(singleSolver.layout.chipPlacements);
-    const layoutGroupIds = Object.keys(singleSolver.layout.groupPlacements);
-    for (let i = 0; i < this.inputProblems.length; i++) {
-      const inputProblem = this.inputProblems[i];
-      const hasAnyChip = layoutChipIds.some(
-        (chipId) => inputProblem.chipMap[chipId]
-      );
-      const hasAnyGroup = layoutGroupIds.some(
-        (groupId) => inputProblem.groupMap[groupId]
-      );
-      if (hasAnyChip || hasAnyGroup) {
-        return i;
-      }
-    }
-    return -1;
-  }
-  resolvePartitionOverlaps(partitionLayout) {
-    const resolvedLayout = {
-      ...partitionLayout,
-      chipPlacements: { ...partitionLayout.chipPlacements },
-      groupPlacements: { ...partitionLayout.groupPlacements }
-    };
-    const overlaps = this.findOverlaps(resolvedLayout.chipPlacements);
-    if (overlaps.length > 0) {
-      this.resolveOverlaps(resolvedLayout.chipPlacements, overlaps);
-    }
-    return resolvedLayout;
-  }
-  positionPartitionsHorizontally(partitionLayouts) {
-    const finalChipPlacements = {};
-    const finalGroupPlacements = {};
-    let currentOffsetX = 0;
-    const partitionGap = 5;
-    for (const partitionLayout of partitionLayouts) {
-      const chipIds = Object.keys(partitionLayout.chipPlacements);
-      if (chipIds.length === 0) continue;
-      const xs = chipIds.map(
-        (chipId) => partitionLayout.chipPlacements[chipId].x
-      );
-      const partitionMinX = Math.min(...xs);
-      const partitionMaxX = Math.max(...xs);
-      const partitionWidth = partitionMaxX - partitionMinX;
-      const offsetX = currentOffsetX - partitionMinX;
-      for (const [chipId, placement] of Object.entries(
-        partitionLayout.chipPlacements
-      )) {
-        finalChipPlacements[chipId] = {
-          x: placement.x + offsetX,
-          y: placement.y,
-          ccwRotationDegrees: placement.ccwRotationDegrees
-        };
-      }
-      for (const [groupId, placement] of Object.entries(
-        partitionLayout.groupPlacements
-      )) {
-        finalGroupPlacements[groupId] = {
-          x: placement.x + offsetX,
-          y: placement.y,
-          ccwRotationDegrees: placement.ccwRotationDegrees
-        };
-      }
-      currentOffsetX += partitionWidth + partitionGap;
-    }
-    return {
-      chipPlacements: finalChipPlacements,
-      groupPlacements: finalGroupPlacements
-    };
-  }
-  findOverlaps(chipPlacements) {
-    const components = this.getComponentBounds(chipPlacements);
-    const overlaps = [];
-    for (let i = 0; i < components.length; i++) {
-      for (let j = i + 1; j < components.length; j++) {
-        const comp1 = components[i];
-        const comp2 = components[j];
-        if (this.boundsOverlap(comp1.bounds, comp2.bounds)) {
-          overlaps.push({
-            chip1: comp1.chipId,
-            chip2: comp2.chipId,
-            bounds1: comp1.bounds,
-            bounds2: comp2.bounds
-          });
-        }
-      }
-    }
-    return overlaps;
-  }
-  getComponentBounds(chipPlacements) {
-    const components = [];
-    for (const [chipId, placement] of Object.entries(chipPlacements)) {
-      let chipSize = { x: 1, y: 1 };
-      for (const inputProblem of this.inputProblems) {
-        const chip = inputProblem.chipMap[chipId];
-        if (chip) {
-          chipSize = chip.size;
-          break;
-        }
-      }
-      const halfWidth = chipSize.x / 2;
-      const halfHeight = chipSize.y / 2;
-      const bounds = {
-        minX: placement.x - halfWidth,
-        maxX: placement.x + halfWidth,
-        minY: placement.y - halfHeight,
-        maxY: placement.y + halfHeight
-      };
-      components.push({
-        chipId,
-        bounds,
-        placement
-      });
-    }
-    return components;
-  }
-  boundsOverlap(bounds1, bounds2) {
-    return !(bounds1.maxX <= bounds2.minX || bounds1.minX >= bounds2.maxX || bounds1.maxY <= bounds2.minY || bounds1.minY >= bounds2.maxY);
-  }
-  resolveOverlaps(chipPlacements, overlaps) {
-    for (const overlap of overlaps) {
-      const { chip1, chip2, bounds1, bounds2 } = overlap;
-      const overlapX = Math.min(
-        bounds1.maxX - bounds2.minX,
-        bounds2.maxX - bounds1.minX
-      );
-      const overlapY = Math.min(
-        bounds1.maxY - bounds2.minY,
-        bounds2.maxY - bounds1.minY
-      );
-      const placement1 = chipPlacements[chip1];
-      const placement2 = chipPlacements[chip2];
-      if (overlapX < overlapY) {
-        const separation = overlapX / 2 + 0.1;
-        if (placement1.x < placement2.x) {
-          placement1.x -= separation;
-          placement2.x += separation;
-        } else {
-          placement1.x += separation;
-          placement2.x -= separation;
-        }
-      } else {
-        const separation = overlapY / 2 + 0.1;
-        if (placement1.y < placement2.y) {
-          placement1.y -= separation;
-          placement2.y += separation;
-        } else {
-          placement1.y += separation;
-          placement2.y -= separation;
-        }
-      }
-    }
-  }
-  visualize() {
-    if (!this.resolvedLayout) {
-      return super.visualize();
-    }
-    const partitionLayouts = this.groupPlacementsByPartition();
-    const partitionVisualizations = [];
-    for (const partitionLayout of partitionLayouts) {
-      if (Object.keys(partitionLayout.chipPlacements).length === 0) continue;
-      const partitionOutputLayout = {
-        chipPlacements: {},
-        groupPlacements: {}
-      };
-      for (const chipId of Object.keys(partitionLayout.chipPlacements)) {
-        if (this.resolvedLayout.chipPlacements[chipId]) {
-          partitionOutputLayout.chipPlacements[chipId] = this.resolvedLayout.chipPlacements[chipId];
-        }
-      }
-      for (const groupId of Object.keys(partitionLayout.groupPlacements)) {
-        if (this.resolvedLayout.groupPlacements[groupId]) {
-          partitionOutputLayout.groupPlacements[groupId] = this.resolvedLayout.groupPlacements[groupId];
-        }
-      }
-      const viz = visualizeInputProblem(
-        partitionLayout.inputProblem,
-        partitionOutputLayout
-      );
-      partitionVisualizations.push({
-        ...viz,
-        title: `Partition ${partitionLayout.partitionIndex + 1}`
-      });
-    }
-    if (partitionVisualizations.length === 0) {
-      return super.visualize();
-    }
-    if (partitionVisualizations.length === 1) {
-      return partitionVisualizations[0];
-    }
-    return stackGraphicsHorizontally4(partitionVisualizations);
-  }
-  getConstructorParams() {
-    return {
-      pinRangeLayoutSolver: this.pinRangeLayoutSolver,
-      inputProblems: this.inputProblems
-    };
-  }
-};
-
-// lib/solvers/LayoutPipelineSolver/LayoutPipelineSolver.ts
-function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
-  return {
-    solverName,
-    solverClass,
-    getConstructorParams,
-    onSolved: opts.onSolved
-  };
-}
-var LayoutPipelineSolver = class extends BaseSolver {
-  chipPartitionsSolver;
-  pinRangeMatchSolver;
-  pinRangeLayoutSolver;
-  pinRangeOverlapSolver;
-  partitionPackingSolver;
-  startTimeOfPhase;
-  endTimeOfPhase;
-  timeSpentOnPhase;
-  firstIterationOfPhase;
-  inputProblem;
-  chipPartitions;
-  pinRanges;
-  pipelineDef = [
-    definePipelineStep(
-      "chipPartitionsSolver",
-      ChipPartitionsSolver,
-      () => [this.inputProblem],
-      {
-        onSolved: (_layoutSolver) => {
-          this.chipPartitions = this.chipPartitionsSolver.partitions;
-        }
-      }
-    ),
-    definePipelineStep(
-      "pinRangeMatchSolver",
-      PinRangeMatchSolver,
-      () => [this.chipPartitions || []],
-      {
-        onSolved: (_solver) => {
-          this.pinRanges = this.pinRangeMatchSolver.getAllPinRanges();
-        }
-      }
-    ),
-    definePipelineStep(
-      "pinRangeLayoutSolver",
-      PinRangeLayoutSolver,
-      () => [this.pinRanges || [], this.chipPartitions || [this.inputProblem]],
-      {
-        onSolved: (_solver) => {
-        }
-      }
-    ),
-    definePipelineStep(
-      "pinRangeOverlapSolver",
-      PinRangeOverlapSolver,
-      () => [
-        this.pinRangeLayoutSolver,
-        this.chipPartitions || [this.inputProblem]
-      ],
-      {
-        onSolved: (_solver) => {
-        }
-      }
-    ),
-    definePipelineStep(
-      "partitionPackingSolver",
-      PartitionPackingSolver,
-      () => [
-        {
-          resolvedLayout: this.pinRangeOverlapSolver.resolvedLayout,
-          laidOutPartitions: this.chipPartitions || [this.inputProblem],
-          inputProblem: this.inputProblem
-        }
-      ],
-      {
-        onSolved: (_solver) => {
-        }
-      }
-    )
-  ];
-  constructor(inputProblem) {
-    super();
-    this.inputProblem = inputProblem;
-    this.MAX_ITERATIONS = 1e3;
-    this.startTimeOfPhase = {};
-    this.endTimeOfPhase = {};
-    this.timeSpentOnPhase = {};
-    this.firstIterationOfPhase = {};
-  }
-  currentPipelineStepIndex = 0;
-  _step() {
-    const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex];
-    if (!pipelineStepDef) {
-      this.solved = true;
-      return;
+      return;
     }
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
@@ -1936,18 +1029,14 @@ var LayoutPipelineSolver = class extends BaseSolver {
       return this.partitionPackingSolver.visualize();
     }
     const chipPartitionsViz = this.chipPartitionsSolver?.visualize();
-    const pinRangeMatchViz = this.pinRangeMatchSolver?.visualize();
-    const pinRangeLayoutViz = this.pinRangeLayoutSolver?.visualize();
-    const pinRangeOverlapViz = this.pinRangeOverlapSolver?.visualize();
+    const packInnerPartitionsViz = this.packInnerPartitionsSolver?.visualize();
     const partitionPackingViz = this.partitionPackingSolver?.visualize();
     const basicLayout = doBasicInputProblemLayout(this.inputProblem);
     const inputViz = visualizeInputProblem(this.inputProblem, basicLayout);
     const visualizations = [
       inputViz,
       chipPartitionsViz,
-      pinRangeMatchViz,
-      pinRangeLayoutViz,
-      pinRangeOverlapViz,
+      packInnerPartitionsViz,
       partitionPackingViz
     ].filter(Boolean).map((viz, stepIndex) => {
       for (const rect of viz.rects ?? []) {
@@ -1987,14 +1076,8 @@ var LayoutPipelineSolver = class extends BaseSolver {
     if (this.partitionPackingSolver?.solved) {
       return this.partitionPackingSolver.visualize();
     }
-    if (this.pinRangeOverlapSolver?.solved) {
-      return this.pinRangeOverlapSolver.visualize();
-    }
-    if (this.pinRangeLayoutSolver?.solved) {
-      return this.pinRangeLayoutSolver.visualize();
-    }
-    if (this.pinRangeMatchSolver?.solved) {
-      return this.pinRangeMatchSolver.visualize();
+    if (this.packInnerPartitionsSolver?.solved) {
+      return this.packInnerPartitionsSolver.visualize();
     }
     if (this.chipPartitionsSolver?.solved) {
       return this.chipPartitionsSolver.visualize();
@@ -2069,31 +1152,6 @@ var LayoutPipelineSolver = class extends BaseSolver {
     let finalLayout;
     if (this.partitionPackingSolver?.solved && this.partitionPackingSolver.finalLayout) {
       finalLayout = this.partitionPackingSolver.finalLayout;
-    } else if (this.pinRangeOverlapSolver?.solved && this.pinRangeOverlapSolver.resolvedLayout) {
-      finalLayout = this.pinRangeOverlapSolver.resolvedLayout;
-    } else if (this.pinRangeLayoutSolver?.solved) {
-      const allChipPlacements = {};
-      const allGroupPlacements = {};
-      for (const singleSolver of this.pinRangeLayoutSolver.completedSolvers) {
-        if (singleSolver.layout) {
-          Object.assign(allChipPlacements, singleSolver.layout.chipPlacements);
-          Object.assign(allGroupPlacements, singleSolver.layout.groupPlacements);
-        }
-      }
-      if (this.pinRangeLayoutSolver.activeSolver?.layout) {
-        Object.assign(
-          allChipPlacements,
-          this.pinRangeLayoutSolver.activeSolver.layout.chipPlacements
-        );
-        Object.assign(
-          allGroupPlacements,
-          this.pinRangeLayoutSolver.activeSolver.layout.groupPlacements
-        );
-      }
-      finalLayout = {
-        chipPlacements: allChipPlacements,
-        groupPlacements: allGroupPlacements
-      };
     } else {
       throw new Error(
         "No layout available. Pipeline may have failed or not progressed far enough."