@tscircuit/matchpack 0.0.13 → 0.0.15

package/dist/index.d.ts

@@ -74,36 +74,12 @@ type InputProblem = {
     chipGap: number;
     /** The minimum gap between two partitions */
     partitionGap: number;
+    decouplingCapsGap?: number;
     inferDecouplingCaps?: boolean;
 };
-
-/**
- * Creates partitions (small subset groups) surrounding complex chips.
- * Divides the layout problem into manageable sections for more efficient processing.
- */
-
-declare class ChipPartitionsSolver extends BaseSolver {
-    inputProblem: InputProblem;
-    partitions: InputProblem[];
-    constructor(inputProblem: InputProblem);
-    _step(): void;
-    /**
-     * Creates partitions by finding connected components through strong pin connections
-     */
-    private createPartitions;
-    /**
-     * Finds the owner chip of a given pin
-     */
-    private findPinOwner;
-    /**
-     * Depth-first search to find connected components
-     */
-    private dfs;
-    /**
-     * Creates a new InputProblem containing only the components in the given partition
-     */
-    private createInputProblemFromPartition;
-    visualize(): GraphicsObject;
+interface PartitionInputProblem extends InputProblem {
+    isPartition?: true;
+    partitionType?: "default" | "decoupling_caps";
 }
 
 /**
@@ -116,6 +92,7 @@ declare class ChipPartitionsSolver extends BaseSolver {
 interface DecouplingCapGroup {
     decouplingCapGroupId: string;
     mainChipId: ChipId;
+    netPair: [NetId, NetId];
     decouplingCapChipIds: ChipId[];
 }
 /**
@@ -128,7 +105,7 @@ declare class IdentifyDecouplingCapsSolver extends BaseSolver {
     inputProblem: InputProblem;
     queuedChips: Chip[];
     outputDecouplingCapGroups: DecouplingCapGroup[];
-    /** Quick lookup of groups by main chip for accumulation */
+    /** Quick lookup of groups by main chip and net pair for accumulation */
     private groupsByMainChipId;
     constructor(inputProblem: InputProblem);
     /** Determine if chip is a 2-pin component with restricted rotation */
@@ -139,14 +116,54 @@ declare class IdentifyDecouplingCapsSolver extends BaseSolver {
     private getStronglyConnectedNeighborChips;
     /** Find the main chip id for a decoupling capacitor candidate */
     private findMainChipIdForCap;
-    /** Adds a decoupling capacitor to the group for the given main chip */
+    /** Get all net IDs connected to a pin */
+    private getNetIdsForPin;
+    /** Get a normalized, sorted pair of net IDs connected across the two pins of a capacitor chip */
+    private getNormalizedNetPair;
+    /** Adds a decoupling capacitor to the group for the given main chip and net pair */
     private addToGroup;
+    lastChip: Chip | null;
     _step(): void;
     visualize(): GraphicsObject;
     getConstructorParams(): [InputProblem];
     computeProgress(): number;
 }
 
+/**
+ * Creates partitions (small subset groups) surrounding complex chips.
+ * Divides the layout problem into manageable sections for more efficient processing.
+ */
+
+declare class ChipPartitionsSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    partitions: PartitionInputProblem[];
+    decouplingCapGroups?: DecouplingCapGroup[];
+    constructor({ inputProblem, decouplingCapGroups, }: {
+        inputProblem: InputProblem;
+        decouplingCapGroups?: DecouplingCapGroup[];
+    });
+    _step(): void;
+    /**
+     * Creates partitions by:
+     * - Separating each decoupling capacitor group into its own partition (caps only, excluding the main chip)
+     * - Partitioning remaining chips by connected components through strong pin connections
+     */
+    private createPartitions;
+    /**
+     * Finds the owner chip of a given pin
+     */
+    private findPinOwner;
+    /**
+     * Depth-first search to find connected components
+     */
+    private dfs;
+    /**
+     * Creates a new InputProblem containing only the components in the given partition
+     */
+    private createInputProblemFromPartition;
+    visualize(): GraphicsObject;
+}
+
 type Placement = Point & {
     ccwRotationDegrees: number;
 };
@@ -161,10 +178,14 @@ type OutputLayout = {
  */
 
 declare class SingleInnerPartitionPackingSolver extends BaseSolver {
-    inputProblem: InputProblem;
+    partitionInputProblem: PartitionInputProblem;
     layout: OutputLayout | null;
     activeSubSolver: PackSolver2 | null;
-    constructor(inputProblem: InputProblem);
+    pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    constructor(params: {
+        partitionInputProblem: PartitionInputProblem;
+        pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    });
     _step(): void;
     private createPackInput;
     private createLayoutFromPackingResult;
@@ -188,7 +209,12 @@ declare class PackInnerPartitionsSolver extends BaseSolver {
     completedSolvers: SingleInnerPartitionPackingSolver[];
     activeSolver: SingleInnerPartitionPackingSolver | null;
     currentPartitionIndex: number;
-    constructor(partitions: InputProblem[]);
+    activeSubSolver: SingleInnerPartitionPackingSolver | null;
+    pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    constructor(params: {
+        partitions: InputProblem[];
+        pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    });
     _step(): void;
     visualize(): GraphicsObject;
     getConstructorParams(): [InputProblem[]];
@@ -237,6 +263,7 @@ declare class LayoutPipelineSolver extends BaseSolver {
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
+    pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
     inputProblem: InputProblem;
     chipPartitions?: ChipPartitionsSolver["partitions"];
     packedPartitions?: PackedPartition[];
@@ -272,4 +299,4 @@ declare class LayoutPipelineSolver extends BaseSolver {
     getOutputLayout(): OutputLayout;
 }
 
-export { type Chip, type ChipId, type ChipPin, type Group, type GroupId, type GroupPin, type InputProblem, LayoutPipelineSolver, type Net, type NetId, type OutputLayout, type PinId, type Placement };
+export { type Chip, type ChipId, type ChipPin, type Group, type GroupId, type GroupPin, type InputProblem, LayoutPipelineSolver, type Net, type NetId, type OutputLayout, type PartitionInputProblem, type PinId, type Placement };

package/dist/index.js

@@ -317,21 +317,45 @@ function doBasicInputProblemLayout(inputProblem) {
 var ChipPartitionsSolver = class extends BaseSolver {
   inputProblem;
   partitions = [];
-  constructor(inputProblem) {
+  decouplingCapGroups;
+  constructor({
+    inputProblem,
+    decouplingCapGroups
+  }) {
     super();
     this.inputProblem = inputProblem;
+    this.decouplingCapGroups = decouplingCapGroups;
   }
   _step() {
     this.partitions = this.createPartitions(this.inputProblem);
     this.solved = true;
   }
   /**
-   * Creates partitions by finding connected components through strong pin connections
+   * Creates partitions by:
+   * - Separating each decoupling capacitor group into its own partition (caps only, excluding the main chip)
+   * - Partitioning remaining chips by connected components through strong pin connections
    */
   createPartitions(inputProblem) {
     const chipIds = Object.keys(inputProblem.chipMap);
+    const decapChipIdSet = /* @__PURE__ */ new Set();
+    const decapGroupPartitions = [];
+    if (this.decouplingCapGroups && this.decouplingCapGroups.length > 0) {
+      for (const group of this.decouplingCapGroups) {
+        const capsOnly = [];
+        for (const capId of group.decouplingCapChipIds) {
+          if (inputProblem.chipMap[capId]) {
+            capsOnly.push(capId);
+            decapChipIdSet.add(capId);
+          }
+        }
+        if (capsOnly.length > 0) {
+          decapGroupPartitions.push(capsOnly);
+        }
+      }
+    }
+    const nonDecapChipIds = chipIds.filter((id) => !decapChipIdSet.has(id));
     const adjacencyMap = /* @__PURE__ */ new Map();
-    for (const chipId of chipIds) {
+    for (const chipId of nonDecapChipIds) {
       adjacencyMap.set(chipId, /* @__PURE__ */ new Set());
     }
     for (const [connKey, isConnected] of Object.entries(
@@ -341,24 +365,31 @@ var ChipPartitionsSolver = class extends BaseSolver {
       const [pin1Id, pin2Id] = connKey.split("-");
       const owner1 = this.findPinOwner(pin1Id, inputProblem);
       const owner2 = this.findPinOwner(pin2Id, inputProblem);
-      if (owner1 && owner2 && owner1 !== owner2) {
+      if (owner1 && owner2 && owner1 !== owner2 && !decapChipIdSet.has(owner1) && !decapChipIdSet.has(owner2)) {
         adjacencyMap.get(owner1).add(owner2);
         adjacencyMap.get(owner2).add(owner1);
       }
     }
     const visited = /* @__PURE__ */ new Set();
-    const partitions = [];
-    for (const componentId of chipIds) {
+    const nonDecapPartitions = [];
+    for (const componentId of nonDecapChipIds) {
       if (!visited.has(componentId)) {
         const partition = this.dfs(componentId, adjacencyMap, visited);
         if (partition.length > 0) {
-          partitions.push(partition);
+          nonDecapPartitions.push(partition);
         }
       }
     }
-    return partitions.map(
-      (partition) => this.createInputProblemFromPartition(partition, inputProblem)
-    );
+    return [
+      ...decapGroupPartitions.map(
+        (partition) => this.createInputProblemFromPartition(partition, inputProblem, {
+          partitionType: "decoupling_caps"
+        })
+      ),
+      ...nonDecapPartitions.map(
+        (partition) => this.createInputProblemFromPartition(partition, inputProblem)
+      )
+    ];
   }
   /**
    * Finds the owner chip of a given pin
@@ -397,7 +428,7 @@ var ChipPartitionsSolver = class extends BaseSolver {
   /**
    * Creates a new InputProblem containing only the components in the given partition
    */
-  createInputProblemFromPartition(partition, originalProblem) {
+  createInputProblemFromPartition(partition, originalProblem, opts) {
     const chipIds = partition;
     const relevantPinIds = /* @__PURE__ */ new Set();
     for (const chipId of chipIds) {
@@ -444,13 +475,14 @@ var ChipPartitionsSolver = class extends BaseSolver {
       }
     }
     return {
+      ...originalProblem,
       chipMap,
       chipPinMap,
       netMap,
       pinStrongConnMap,
       netConnMap,
-      chipGap: originalProblem.chipGap,
-      partitionGap: originalProblem.partitionGap
+      isPartition: true,
+      partitionType: opts?.partitionType
     };
   }
   visualize() {
@@ -468,10 +500,13 @@ var ChipPartitionsSolver = class extends BaseSolver {
 
 // lib/utils/getColorFromString.ts
 var getColorFromString = (string, alpha = 1) => {
-  const hash = string.split("").reduce((acc, char) => {
-    return acc * 31 + char.charCodeAt(0);
-  }, 0);
-  return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
+  let hash = 0;
+  for (let i = 0; i < string.length; i++) {
+    const char = string.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `hsl(${Math.abs(hash) % 360}, 70%, 50%, ${alpha})`;
 };
 
 // lib/solvers/IdentifyDecouplingCapsSolver/IdentifyDecouplingCapsSolver.ts
@@ -479,7 +514,7 @@ var IdentifyDecouplingCapsSolver = class extends BaseSolver {
   inputProblem;
   queuedChips;
   outputDecouplingCapGroups = [];
-  /** Quick lookup of groups by main chip for accumulation */
+  /** Quick lookup of groups by main chip and net pair for accumulation */
   groupsByMainChipId = /* @__PURE__ */ new Map();
   constructor(inputProblem) {
     super();
@@ -539,33 +574,64 @@ var IdentifyDecouplingCapsSolver = class extends BaseSolver {
     }
     return best ? best.id : null;
   }
-  /** Adds a decoupling capacitor to the group for the given main chip */
-  addToGroup(mainChipId, capChipId) {
-    let group = this.groupsByMainChipId.get(mainChipId);
+  /** Get all net IDs connected to a pin */
+  getNetIdsForPin(pinId) {
+    const nets = /* @__PURE__ */ new Set();
+    for (const [connKey, connected] of Object.entries(
+      this.inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      const [p, n] = connKey.split("-");
+      if (p === pinId) nets.add(n);
+    }
+    return nets;
+  }
+  /** Get a normalized, sorted pair of net IDs connected across the two pins of a capacitor chip */
+  getNormalizedNetPair(capChip) {
+    if (capChip.pins.length !== 2) return null;
+    const nets = /* @__PURE__ */ new Set();
+    for (const pinId of capChip.pins) {
+      const pinNets = this.getNetIdsForPin(pinId);
+      for (const n of pinNets) nets.add(n);
+    }
+    if (nets.size !== 2) return null;
+    const [a, b] = Array.from(nets).sort();
+    return [a, b];
+  }
+  /** Adds a decoupling capacitor to the group for the given main chip and net pair */
+  addToGroup(mainChipId, netPair, capChipId) {
+    const [n1, n2] = netPair;
+    const groupKey = `${mainChipId}__${n1}__${n2}`;
+    let group = this.groupsByMainChipId.get(groupKey);
     if (!group) {
       group = {
-        decouplingCapGroupId: `decap_group_${mainChipId}`,
+        decouplingCapGroupId: `decap_group_${mainChipId}__${n1}__${n2}`,
         mainChipId,
+        netPair: [n1, n2],
         decouplingCapChipIds: []
       };
-      this.groupsByMainChipId.set(mainChipId, group);
+      this.groupsByMainChipId.set(groupKey, group);
       this.outputDecouplingCapGroups.push(group);
     }
     if (!group.decouplingCapChipIds.includes(capChipId)) {
       group.decouplingCapChipIds.push(capChipId);
     }
   }
+  lastChip = null;
   _step() {
     const currentChip = this.queuedChips.shift();
+    this.lastChip = currentChip ?? null;
     if (!currentChip) {
       this.solved = true;
       return;
     }
-    const candidate = this.isTwoPinRestrictedRotation(currentChip) && this.pinsOnOppositeYSides(currentChip);
-    if (!candidate) return;
+    const isDecouplingCap = this.isTwoPinRestrictedRotation(currentChip) && this.pinsOnOppositeYSides(currentChip);
+    if (!isDecouplingCap) return;
     const mainChipId = this.findMainChipIdForCap(currentChip);
     if (!mainChipId) return;
-    this.addToGroup(mainChipId, currentChip.chipId);
+    const netPair = this.getNormalizedNetPair(currentChip);
+    if (!netPair) return;
+    this.addToGroup(mainChipId, netPair, currentChip.chipId);
   }
   visualize() {
     const basicLayout = doBasicInputProblemLayout(this.inputProblem);
@@ -573,38 +639,25 @@ var IdentifyDecouplingCapsSolver = class extends BaseSolver {
       this.inputProblem,
       basicLayout
     );
-    const chipRoleMap = /* @__PURE__ */ new Map();
+    const chipDecapGroupMap = /* @__PURE__ */ new Map();
     for (const group of this.outputDecouplingCapGroups) {
-      const color = getColorFromString(group.mainChipId, 0.8);
-      chipRoleMap.set(group.mainChipId, { type: "main", color });
+      chipDecapGroupMap.set(group.mainChipId, group);
       for (const capChipId of group.decouplingCapChipIds) {
-        chipRoleMap.set(capChipId, { type: "decap", color });
+        chipDecapGroupMap.set(capChipId, group);
       }
     }
     for (const rect of graphics.rects || []) {
-      rect.fill = "rgba(0,0,0,0.5)";
+      if (rect.label !== this.lastChip?.chipId) {
+        rect.fill = "rgba(0,0,0,0.5)";
+      }
     }
     for (const rect of graphics.rects || []) {
       const chipId = rect.label;
-      const role = chipRoleMap.get(chipId);
-      if (!role) continue;
-      const alpha = role.type === "main" ? 0.18 : 0.36;
+      const group = chipDecapGroupMap.get(chipId);
+      if (!group) continue;
       rect.label = `${rect.label}
-${role.type}`;
-      rect.fill = getColorFromString(role.color, alpha);
-    }
-    if (!graphics.texts) graphics.texts = [];
-    for (const rect of graphics.rects || []) {
-      const chipId = rect.label;
-      const role = chipRoleMap.get(chipId);
-      if (!role) continue;
-      graphics.texts.push({
-        x: rect.center.x,
-        y: rect.center.y - (rect.height || 0) / 2,
-        text: role.type === "main" ? "MAIN" : "DECAP",
-        fillColor: role.type === "main" ? role.color : "rgba(0,0,0,0.6)",
-        fontSize: 8
-      });
+${group.decouplingCapGroupId}`;
+      rect.fill = getColorFromString(group.decouplingCapGroupId, 0.8);
     }
     return graphics;
   }
@@ -622,14 +675,17 @@ ${role.type}`;
 import { PackSolver2 } from "calculate-packing";
 
 // lib/utils/networkFiltering.ts
-function createFilteredNetworkMapping(inputProblem) {
+function createFilteredNetworkMapping(params) {
+  const { inputProblem, pinIdToStronglyConnectedPins } = params;
   const pinToNetworkMap = /* @__PURE__ */ new Map();
   const filteredPins = /* @__PURE__ */ new Set();
+  let hasStrongConnections = false;
   const strongConnectedChipSides = /* @__PURE__ */ new Map();
   for (const [connKey, connected] of Object.entries(
     inputProblem.pinStrongConnMap
   )) {
     if (!connected) continue;
+    hasStrongConnections = true;
     const pins = connKey.split("-");
     if (pins.length === 2 && pins[0] && pins[1]) {
       const pin1 = inputProblem.chipPinMap[pins[0]];
@@ -652,45 +708,59 @@ function createFilteredNetworkMapping(inputProblem) {
       }
     }
   }
-  for (const [connKey, connected] of Object.entries(inputProblem.netConnMap)) {
-    if (!connected) continue;
-    const [pinId, netId] = connKey.split("-");
-    if (pinId && netId) {
-      const pin = inputProblem.chipPinMap[pinId];
-      if (!pin) continue;
-      const chipId = pinId.split(".")[0];
-      let shouldIncludeInNetwork = true;
-      for (const [
-        strongKey,
-        strongSides
-      ] of strongConnectedChipSides.entries()) {
-        const [fromChip, toChip] = strongKey.split("-");
-        if (fromChip === chipId) {
-          for (const [otherConnKey, otherConnected] of Object.entries(
-            inputProblem.netConnMap
-          )) {
-            if (!otherConnected) continue;
-            const [otherPinId, otherNetId] = otherConnKey.split("-");
-            if (otherNetId === netId && otherPinId && otherPinId !== pinId) {
-              const otherPin = inputProblem.chipPinMap[otherPinId];
-              if (!otherPin) continue;
-              const otherChipId = otherPinId.split(".")[0];
-              if (otherChipId === toChip) {
-                if (!strongSides.has(otherPin.side)) {
-                  shouldIncludeInNetwork = false;
-                  break;
+  if (hasStrongConnections) {
+    for (const [connKey, connected] of Object.entries(
+      inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      const [pinId, netId] = connKey.split("-");
+      if (pinId && netId) {
+        filteredPins.add(pinId);
+      }
+    }
+  } else {
+    for (const [connKey, connected] of Object.entries(
+      inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      const [pinId, netId] = connKey.split("-");
+      if (pinId && netId) {
+        const pin = inputProblem.chipPinMap[pinId];
+        if (!pin) continue;
+        const chipId = pinId.split(".")[0];
+        let shouldIncludeInNetwork = true;
+        for (const [
+          strongKey,
+          strongSides
+        ] of strongConnectedChipSides.entries()) {
+          const [fromChip, toChip] = strongKey.split("-");
+          if (fromChip === chipId) {
+            for (const [otherConnKey, otherConnected] of Object.entries(
+              inputProblem.netConnMap
+            )) {
+              if (!otherConnected) continue;
+              const [otherPinId, otherNetId] = otherConnKey.split("-");
+              if (otherNetId === netId && otherPinId && otherPinId !== pinId) {
+                const otherPin = inputProblem.chipPinMap[otherPinId];
+                if (!otherPin) continue;
+                const otherChipId = otherPinId.split(".")[0];
+                if (otherChipId === toChip) {
+                  if (!strongSides.has(otherPin.side)) {
+                    shouldIncludeInNetwork = false;
+                    break;
+                  }
                 }
               }
             }
           }
         }
-      }
-      if (shouldIncludeInNetwork) {
-        pinToNetworkMap.set(pinId, netId);
-      } else {
-        const disconnectedNetworkId = `${pinId}_opposite-strong-side-disconnected`;
-        pinToNetworkMap.set(pinId, disconnectedNetworkId);
-        filteredPins.add(pinId);
+        if (shouldIncludeInNetwork) {
+          pinToNetworkMap.set(pinId, netId);
+        } else {
+          const disconnectedNetworkId = `${pinId}_opposite-strong-side-disconnected`;
+          pinToNetworkMap.set(pinId, disconnectedNetworkId);
+          filteredPins.add(pinId);
+        }
       }
     }
   }
@@ -736,11 +806,13 @@ var getPadsBoundingBox = (pads) => {
 // lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
 var PIN_SIZE = 0.1;
 var SingleInnerPartitionPackingSolver = class extends BaseSolver {
-  inputProblem;
+  partitionInputProblem;
   layout = null;
-  constructor(inputProblem) {
+  pinIdToStronglyConnectedPins;
+  constructor(params) {
     super();
-    this.inputProblem = inputProblem;
+    this.partitionInputProblem = params.partitionInputProblem;
+    this.pinIdToStronglyConnectedPins = params.pinIdToStronglyConnectedPins;
   }
   _step() {
     if (!this.activeSubSolver) {
@@ -763,53 +835,55 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
     }
   }
   createPackInput() {
-    const { pinToNetworkMap } = createFilteredNetworkMapping(this.inputProblem);
-    const packComponents = Object.entries(this.inputProblem.chipMap).map(
-      ([chipId, chip]) => {
-        const pads = [];
-        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: PIN_SIZE, y: PIN_SIZE }
-            // Small size for pins
-          });
-        }
-        const padsBoundingBox = getPadsBoundingBox(pads);
-        const padsBoundingBoxSize = {
-          x: padsBoundingBox.maxX - padsBoundingBox.minX,
-          y: padsBoundingBox.maxY - padsBoundingBox.minY
-        };
+    const pinToNetworkMap = createFilteredNetworkMapping({
+      inputProblem: this.partitionInputProblem,
+      pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
+    }).pinToNetworkMap;
+    const packComponents = Object.entries(
+      this.partitionInputProblem.chipMap
+    ).map(([chipId, chip]) => {
+      const pads = [];
+      for (const pinId of chip.pins) {
+        const pin = this.partitionInputProblem.chipPinMap[pinId];
+        if (!pin) continue;
+        const networkId = pinToNetworkMap.get(pinId) || `${pinId}_isolated`;
         pads.push({
-          padId: `${chipId}_body`,
-          networkId: `${chipId}_body_disconnected`,
+          padId: pinId,
+          networkId,
           type: "rect",
-          offset: { x: 0, y: 0 },
-          size: {
-            x: Math.max(padsBoundingBoxSize.x, chip.size.x),
-            y: Math.max(padsBoundingBoxSize.y, chip.size.y)
-          }
+          offset: { x: pin.offset.x, y: pin.offset.y },
+          size: { x: PIN_SIZE, y: PIN_SIZE }
+          // Small size for pins
         });
-        return {
-          componentId: chipId,
-          pads,
-          availableRotationDegrees: chip.availableRotations || [
-            0,
-            90,
-            180,
-            270
-          ]
-        };
       }
-    );
+      const padsBoundingBox = getPadsBoundingBox(pads);
+      const padsBoundingBoxSize = {
+        x: padsBoundingBox.maxX - padsBoundingBox.minX,
+        y: padsBoundingBox.maxY - padsBoundingBox.minY
+      };
+      pads.push({
+        padId: `${chipId}_body`,
+        networkId: `${chipId}_body_disconnected`,
+        type: "rect",
+        offset: { x: 0, y: 0 },
+        size: {
+          x: Math.max(padsBoundingBoxSize.x, chip.size.x),
+          y: Math.max(padsBoundingBoxSize.y, chip.size.y)
+        }
+      });
+      return {
+        componentId: chipId,
+        pads,
+        availableRotationDegrees: chip.availableRotations || [0, 90, 180, 270]
+      };
+    });
+    let minGap = this.partitionInputProblem.chipGap;
+    if (this.partitionInputProblem.partitionType === "decoupling_caps") {
+      minGap = this.partitionInputProblem.decouplingCapsGap ?? minGap;
+    }
     return {
       components: packComponents,
-      minGap: this.inputProblem.chipGap,
+      minGap,
       packOrderStrategy: "largest_to_smallest",
       packPlacementStrategy: "minimum_closest_sum_squared_distance"
     };
@@ -834,13 +908,13 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
       return this.activeSubSolver.visualize();
     }
     if (!this.layout) {
-      const basicLayout = doBasicInputProblemLayout(this.inputProblem);
-      return visualizeInputProblem(this.inputProblem, basicLayout);
+      const basicLayout = doBasicInputProblemLayout(this.partitionInputProblem);
+      return visualizeInputProblem(this.partitionInputProblem, basicLayout);
     }
-    return visualizeInputProblem(this.inputProblem, this.layout);
+    return visualizeInputProblem(this.partitionInputProblem, this.layout);
   }
   getConstructorParams() {
-    return [this.inputProblem];
+    return [this.partitionInputProblem];
   }
 };
 
@@ -852,9 +926,11 @@ var PackInnerPartitionsSolver = class extends BaseSolver {
   completedSolvers = [];
   activeSolver = null;
   currentPartitionIndex = 0;
-  constructor(partitions) {
+  pinIdToStronglyConnectedPins;
+  constructor(params) {
     super();
-    this.partitions = partitions;
+    this.partitions = params.partitions;
+    this.pinIdToStronglyConnectedPins = params.pinIdToStronglyConnectedPins;
   }
   _step() {
     if (this.currentPartitionIndex >= this.partitions.length) {
@@ -863,9 +939,10 @@ var PackInnerPartitionsSolver = class extends BaseSolver {
     }
     if (!this.activeSolver) {
       const currentPartition = this.partitions[this.currentPartitionIndex];
-      this.activeSolver = new SingleInnerPartitionPackingSolver(
-        currentPartition
-      );
+      this.activeSolver = new SingleInnerPartitionPackingSolver({
+        partitionInputProblem: currentPartition,
+        pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
+      });
       this.activeSubSolver = this.activeSolver;
     }
     this.activeSolver.step();
@@ -1179,6 +1256,29 @@ var PartitionPackingSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/LayoutPipelineSolver/getPinIdToStronglyConnectedPinsObj.ts
+var getPinIdToStronglyConnectedPinsObj = (inputProblem) => {
+  const pinIdToStronglyConnectedPins = {};
+  const pinIds = Object.keys(inputProblem.chipPinMap);
+  for (let i = 0; i < pinIds.length; i++) {
+    for (let j = i + 1; j < pinIds.length; j++) {
+      const pinId1 = pinIds[i];
+      const pinId2 = pinIds[j];
+      if (inputProblem.pinStrongConnMap[`${pinId1}-${pinId2}`] || inputProblem.pinStrongConnMap[`${pinId2}-${pinId1}`]) {
+        pinIdToStronglyConnectedPins[pinId1] ??= [];
+        pinIdToStronglyConnectedPins[pinId2] ??= [];
+        pinIdToStronglyConnectedPins[pinId1].push(
+          inputProblem.chipPinMap[pinId2]
+        );
+        pinIdToStronglyConnectedPins[pinId2].push(
+          inputProblem.chipPinMap[pinId1]
+        );
+      }
+    }
+  }
+  return pinIdToStronglyConnectedPins;
+};
+
 // lib/solvers/LayoutPipelineSolver/LayoutPipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -1197,6 +1297,8 @@ var LayoutPipelineSolver = class extends BaseSolver {
   endTimeOfPhase;
   timeSpentOnPhase;
   firstIterationOfPhase;
+  // Computed utility objects
+  pinIdToStronglyConnectedPins;
   inputProblem;
   chipPartitions;
   packedPartitions;
@@ -1213,7 +1315,12 @@ var LayoutPipelineSolver = class extends BaseSolver {
     definePipelineStep(
       "chipPartitionsSolver",
       ChipPartitionsSolver,
-      () => [this.inputProblem],
+      () => [
+        {
+          inputProblem: this.inputProblem,
+          decouplingCapGroups: this.identifyDecouplingCapsSolver?.outputDecouplingCapGroups
+        }
+      ],
       {
         onSolved: (_layoutSolver) => {
           this.chipPartitions = this.chipPartitionsSolver.partitions;
@@ -1223,7 +1330,12 @@ var LayoutPipelineSolver = class extends BaseSolver {
     definePipelineStep(
       "packInnerPartitionsSolver",
       PackInnerPartitionsSolver,
-      () => [this.chipPartitions || [this.inputProblem]],
+      () => [
+        {
+          partitions: this.chipPartitions,
+          pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
+        }
+      ],
       {
         onSolved: (_solver) => {
           this.packedPartitions = this.packInnerPartitionsSolver.packedPartitions;
@@ -1253,6 +1365,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
     this.endTimeOfPhase = {};
     this.timeSpentOnPhase = {};
     this.firstIterationOfPhase = {};
+    this.pinIdToStronglyConnectedPins = getPinIdToStronglyConnectedPinsObj(inputProblem);
   }
   currentPipelineStepIndex = 0;
   _step() {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "files": [
     "dist"
   ],
@@ -23,7 +23,7 @@
     "bpc-graph": "^0.0.66",
     "calculate-packing": "^0.0.31",
     "circuit-json": "^0.0.226",
-    "graphics-debug": "^0.0.62",
+    "graphics-debug": "^0.0.64",
     "react-cosmos": "^7.0.0",
     "react-cosmos-plugin-vite": "^7.0.0",
     "tscircuit": "^0.0.593",