@tscircuit/matchpack 0.0.11 → 0.0.13

package/dist/index.d.ts

@@ -47,6 +47,7 @@ type Chip = {
     chipId: ChipId;
     pins: PinId[];
     size: Point;
+    isDecouplingCap?: boolean;
     availableRotations?: Array<0 | 90 | 180 | 270>;
 };
 type Group = {
@@ -73,6 +74,7 @@ type InputProblem = {
     chipGap: number;
     /** The minimum gap between two partitions */
     partitionGap: number;
+    inferDecouplingCaps?: boolean;
 };
 
 /**
@@ -104,6 +106,47 @@ declare class ChipPartitionsSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+/**
+ * Identifies decoupling capacitor groups based on specific criteria:
+ * 1. Component has exactly 2 pins and restricted rotation (0/180 only or no rotation)
+ * 2. One pin indirectly connected to net with "y+" restriction, one to "y-" restriction
+ * 3. At least one pin directly connected to another chip
+ */
+
+interface DecouplingCapGroup {
+    decouplingCapGroupId: string;
+    mainChipId: ChipId;
+    decouplingCapChipIds: ChipId[];
+}
+/**
+ * Identify decoupling capacitor groups based on specific criteria:
+ * 1. Component has exactly 2 pins and restricted rotation (0/180 only or no rotation)
+ * 2. One pin indirectly connected to net with "y+" restriction, one to "y-" restriction
+ * 3. At least one pin directly connected to a chip (the main chip, typically a microcontroller)
+ */
+declare class IdentifyDecouplingCapsSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    queuedChips: Chip[];
+    outputDecouplingCapGroups: DecouplingCapGroup[];
+    /** Quick lookup of groups by main chip for accumulation */
+    private groupsByMainChipId;
+    constructor(inputProblem: InputProblem);
+    /** Determine if chip is a 2-pin component with restricted rotation */
+    private isTwoPinRestrictedRotation;
+    /** Check that the two pins are on opposite Y sides (y+ and y-) */
+    private pinsOnOppositeYSides;
+    /** Get chips strongly connected (direct pin-to-pin) to this pin */
+    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 */
+    private addToGroup;
+    _step(): void;
+    visualize(): GraphicsObject;
+    getConstructorParams(): [InputProblem];
+    computeProgress(): number;
+}
+
 type Placement = Point & {
     ccwRotationDegrees: number;
 };
@@ -186,6 +229,7 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: LayoutPipelineSolver) => void;
 };
 declare class LayoutPipelineSolver extends BaseSolver {
+    identifyDecouplingCapsSolver?: IdentifyDecouplingCapsSolver;
     chipPartitionsSolver?: ChipPartitionsSolver;
     packInnerPartitionsSolver?: PackInnerPartitionsSolver;
     partitionPackingSolver?: PartitionPackingSolver;
@@ -196,7 +240,7 @@ declare class LayoutPipelineSolver extends BaseSolver {
     inputProblem: InputProblem;
     chipPartitions?: ChipPartitionsSolver["partitions"];
     packedPartitions?: PackedPartition[];
-    pipelineDef: (PipelineStep<typeof ChipPartitionsSolver> | PipelineStep<typeof PackInnerPartitionsSolver> | PipelineStep<typeof PartitionPackingSolver>)[];
+    pipelineDef: (PipelineStep<typeof IdentifyDecouplingCapsSolver> | PipelineStep<typeof ChipPartitionsSolver> | PipelineStep<typeof PackInnerPartitionsSolver> | PipelineStep<typeof PartitionPackingSolver>)[];
     constructor(inputProblem: InputProblem);
     currentPipelineStepIndex: number;
     _step(): void;

package/dist/index.js

@@ -239,7 +239,19 @@ function visualizeInputProblem(inputProblem, basicLayout) {
 
 // lib/solvers/LayoutPipelineSolver/doBasicInputProblemLayout.ts
 import { pack } from "calculate-packing";
+
+// lib/solvers/LayoutPipelineSolver/hashInputProblem.ts
+var hashInputProblem = (inputProblem) => {
+  return JSON.stringify(inputProblem);
+};
+
+// lib/solvers/LayoutPipelineSolver/doBasicInputProblemLayout.ts
+var cachedProblems = /* @__PURE__ */ new Map();
 function doBasicInputProblemLayout(inputProblem) {
+  const problemHash = hashInputProblem(inputProblem);
+  if (cachedProblems.has(problemHash)) {
+    return structuredClone(cachedProblems.get(problemHash));
+  }
   const components = Object.entries(inputProblem.chipMap).map(
     ([chipId, chip]) => {
       const chipPins = chip.pins.map((pinId) => inputProblem.chipPinMap[pinId]);
@@ -292,11 +304,13 @@ function doBasicInputProblemLayout(inputProblem) {
       ccwRotationDegrees: component.ccwRotationOffset
     };
   }
-  return {
+  const outputLayout = {
     chipPlacements,
     groupPlacements: {}
     // No groups for now
   };
+  cachedProblems.set(problemHash, outputLayout);
+  return structuredClone(outputLayout);
 }
 
 // lib/solvers/ChipPartitionsSolver/ChipPartitionsSolver.ts
@@ -452,6 +466,158 @@ 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})`;
+};
+
+// lib/solvers/IdentifyDecouplingCapsSolver/IdentifyDecouplingCapsSolver.ts
+var IdentifyDecouplingCapsSolver = class extends BaseSolver {
+  inputProblem;
+  queuedChips;
+  outputDecouplingCapGroups = [];
+  /** Quick lookup of groups by main chip for accumulation */
+  groupsByMainChipId = /* @__PURE__ */ new Map();
+  constructor(inputProblem) {
+    super();
+    this.inputProblem = inputProblem;
+    this.queuedChips = Object.values(inputProblem.chipMap);
+  }
+  /** Determine if chip is a 2-pin component with restricted rotation */
+  isTwoPinRestrictedRotation(chip) {
+    if (chip.pins.length !== 2) return false;
+    if (!chip.availableRotations) return false;
+    const allowed = /* @__PURE__ */ new Set([0, 180]);
+    return chip.availableRotations.length > 0 && chip.availableRotations.every((r) => allowed.has(r));
+  }
+  /** Check that the two pins are on opposite Y sides (y+ and y-) */
+  pinsOnOppositeYSides(chip) {
+    if (chip.pins.length !== 2) return false;
+    const [p1, p2] = chip.pins;
+    const cp1 = this.inputProblem.chipPinMap[p1];
+    const cp2 = this.inputProblem.chipPinMap[p2];
+    if (!cp1 || !cp2) return false;
+    const sides = /* @__PURE__ */ new Set([cp1.side, cp2.side]);
+    return sides.has("y+") && sides.has("y-");
+  }
+  /** Get chips strongly connected (direct pin-to-pin) to this pin */
+  getStronglyConnectedNeighborChips(pinId) {
+    const neighbors = /* @__PURE__ */ new Set();
+    for (const [connKey, connected] of Object.entries(
+      this.inputProblem.pinStrongConnMap
+    )) {
+      if (!connected) continue;
+      const [a, b] = connKey.split("-");
+      if (a === pinId) {
+        const otherChipId = b.split(".")[0];
+        neighbors.add(otherChipId);
+      } else if (b === pinId) {
+        const otherChipId = a.split(".")[0];
+        neighbors.add(otherChipId);
+      }
+    }
+    return neighbors;
+  }
+  /** Find the main chip id for a decoupling capacitor candidate */
+  findMainChipIdForCap(capChip) {
+    const strongNeighbors = /* @__PURE__ */ new Map();
+    for (const pinId of capChip.pins) {
+      const neighbors = this.getStronglyConnectedNeighborChips(pinId);
+      for (const n of neighbors) {
+        if (n === capChip.chipId) continue;
+        strongNeighbors.set(n, (strongNeighbors.get(n) || 0) + 1);
+      }
+    }
+    if (strongNeighbors.size === 0) return null;
+    let best = null;
+    for (const [id, score] of strongNeighbors.entries()) {
+      if (!best || score > best.score || score === best.score && id < best.id)
+        best = { id, score };
+    }
+    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);
+    if (!group) {
+      group = {
+        decouplingCapGroupId: `decap_group_${mainChipId}`,
+        mainChipId,
+        decouplingCapChipIds: []
+      };
+      this.groupsByMainChipId.set(mainChipId, group);
+      this.outputDecouplingCapGroups.push(group);
+    }
+    if (!group.decouplingCapChipIds.includes(capChipId)) {
+      group.decouplingCapChipIds.push(capChipId);
+    }
+  }
+  _step() {
+    const currentChip = this.queuedChips.shift();
+    if (!currentChip) {
+      this.solved = true;
+      return;
+    }
+    const candidate = this.isTwoPinRestrictedRotation(currentChip) && this.pinsOnOppositeYSides(currentChip);
+    if (!candidate) return;
+    const mainChipId = this.findMainChipIdForCap(currentChip);
+    if (!mainChipId) return;
+    this.addToGroup(mainChipId, currentChip.chipId);
+  }
+  visualize() {
+    const basicLayout = doBasicInputProblemLayout(this.inputProblem);
+    const graphics = visualizeInputProblem(
+      this.inputProblem,
+      basicLayout
+    );
+    const chipRoleMap = /* @__PURE__ */ new Map();
+    for (const group of this.outputDecouplingCapGroups) {
+      const color = getColorFromString(group.mainChipId, 0.8);
+      chipRoleMap.set(group.mainChipId, { type: "main", color });
+      for (const capChipId of group.decouplingCapChipIds) {
+        chipRoleMap.set(capChipId, { type: "decap", color });
+      }
+    }
+    for (const rect of graphics.rects || []) {
+      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;
+      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
+      });
+    }
+    return graphics;
+  }
+  getConstructorParams() {
+    return [this.inputProblem];
+  }
+  computeProgress() {
+    const total = Object.keys(this.inputProblem.chipMap).length || 1;
+    const processed = total - this.queuedChips.length;
+    return Math.min(1, Math.max(0, processed / total));
+  }
+};
+
 // lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
 import { PackSolver2 } from "calculate-packing";
 
@@ -645,7 +811,7 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
       components: packComponents,
       minGap: this.inputProblem.chipGap,
       packOrderStrategy: "largest_to_smallest",
-      packPlacementStrategy: "minimum_sum_squared_distance_to_network"
+      packPlacementStrategy: "minimum_closest_sum_squared_distance"
     };
   }
   createLayoutFromPackingResult(packedComponents) {
@@ -668,7 +834,8 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
       return this.activeSubSolver.visualize();
     }
     if (!this.layout) {
-      return super.visualize();
+      const basicLayout = doBasicInputProblemLayout(this.inputProblem);
+      return visualizeInputProblem(this.inputProblem, basicLayout);
     }
     return visualizeInputProblem(this.inputProblem, this.layout);
   }
@@ -1022,6 +1189,7 @@ function definePipelineStep(solverName, solverClass, getConstructorParams, opts
   };
 }
 var LayoutPipelineSolver = class extends BaseSolver {
+  identifyDecouplingCapsSolver;
   chipPartitionsSolver;
   packInnerPartitionsSolver;
   partitionPackingSolver;
@@ -1033,6 +1201,15 @@ var LayoutPipelineSolver = class extends BaseSolver {
   chipPartitions;
   packedPartitions;
   pipelineDef = [
+    definePipelineStep(
+      "identifyDecouplingCapsSolver",
+      IdentifyDecouplingCapsSolver,
+      () => [this.inputProblem],
+      {
+        onSolved: (_layoutSolver) => {
+        }
+      }
+    ),
     definePipelineStep(
       "chipPartitionsSolver",
       ChipPartitionsSolver,
@@ -1120,6 +1297,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
     if (this.solved && this.partitionPackingSolver?.solved) {
       return this.partitionPackingSolver.visualize();
     }
+    const identifyDecouplingCapsViz = this.identifyDecouplingCapsSolver?.visualize();
     const chipPartitionsViz = this.chipPartitionsSolver?.visualize();
     const packInnerPartitionsViz = this.packInnerPartitionsSolver?.visualize();
     const partitionPackingViz = this.partitionPackingSolver?.visualize();
@@ -1127,6 +1305,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
     const inputViz = visualizeInputProblem(this.inputProblem, basicLayout);
     const visualizations = [
       inputViz,
+      identifyDecouplingCapsViz,
       chipPartitionsViz,
       packInnerPartitionsViz,
       partitionPackingViz
@@ -1174,6 +1353,9 @@ var LayoutPipelineSolver = class extends BaseSolver {
     if (this.chipPartitionsSolver?.solved) {
       return this.chipPartitionsSolver.visualize();
     }
+    if (this.identifyDecouplingCapsSolver?.solved) {
+      return this.identifyDecouplingCapsSolver.visualize();
+    }
     return super.preview();
   }
   /**

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "files": [
     "dist"
   ],
@@ -21,7 +21,7 @@
     "@tscircuit/schematic-viewer": "^2.0.26",
     "@types/bun": "latest",
     "bpc-graph": "^0.0.66",
-    "calculate-packing": "^0.0.28",
+    "calculate-packing": "^0.0.31",
     "circuit-json": "^0.0.226",
     "graphics-debug": "^0.0.62",
     "react-cosmos": "^7.0.0",