@tscircuit/matchpack 0.0.6 → 0.0.8

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { GraphicsObject } from 'graphics-debug';
 import { Point, Bounds } from '@tscircuit/math-utils';
-import { PhasedPackSolver } from 'calculate-packing';
+import { PackSolver2 } from 'calculate-packing';
 
 declare class BaseSolver {
     MAX_ITERATIONS: number;
@@ -120,7 +120,7 @@ type OutputLayout = {
 declare class SingleInnerPartitionPackingSolver extends BaseSolver {
     inputProblem: InputProblem;
     layout: OutputLayout | null;
-    phasedPackSolver: PhasedPackSolver | null;
+    activeSubSolver: PackSolver2 | null;
     constructor(inputProblem: InputProblem);
     _step(): void;
     private createPackInput;
@@ -164,7 +164,7 @@ declare class PartitionPackingSolver extends BaseSolver {
     packedPartitions: PackedPartition[];
     inputProblem: InputProblem;
     finalLayout: OutputLayout | null;
-    phasedPackSolver: PhasedPackSolver | null;
+    packSolver2: PackSolver2 | null;
     constructor(input: PartitionPackingSolverInput);
     _step(): void;
     private organizePackedPartitions;

package/dist/index.js

@@ -1,6 +1,6 @@
 // lib/solvers/BaseSolver.ts
 var BaseSolver = class {
-  MAX_ITERATIONS = 1e3;
+  MAX_ITERATIONS = 1e5;
   solved = false;
   failed = false;
   iterations = 0;
@@ -453,31 +453,127 @@ var ChipPartitionsSolver = class extends BaseSolver {
 };
 
 // lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
-import { PhasedPackSolver } from "calculate-packing";
+import { PackSolver2 } from "calculate-packing";
+
+// lib/utils/networkFiltering.ts
+function createFilteredNetworkMapping(inputProblem) {
+  const pinToNetworkMap = /* @__PURE__ */ new Map();
+  const filteredPins = /* @__PURE__ */ new Set();
+  const strongConnectedChipSides = /* @__PURE__ */ new Map();
+  for (const [connKey, connected] of Object.entries(
+    inputProblem.pinStrongConnMap
+  )) {
+    if (!connected) continue;
+    const pins = connKey.split("-");
+    if (pins.length === 2 && pins[0] && pins[1]) {
+      const pin1 = inputProblem.chipPinMap[pins[0]];
+      const pin2 = inputProblem.chipPinMap[pins[1]];
+      if (pin1 && pin2) {
+        const chip1Id = pins[0].split(".")[0];
+        const chip2Id = pins[1].split(".")[0];
+        if (chip1Id && chip2Id && chip1Id !== chip2Id) {
+          const key1 = `${chip1Id}-${chip2Id}`;
+          const key2 = `${chip2Id}-${chip1Id}`;
+          if (!strongConnectedChipSides.has(key1)) {
+            strongConnectedChipSides.set(key1, /* @__PURE__ */ new Set());
+          }
+          if (!strongConnectedChipSides.has(key2)) {
+            strongConnectedChipSides.set(key2, /* @__PURE__ */ new Set());
+          }
+          strongConnectedChipSides.get(key1).add(pin1.side);
+          strongConnectedChipSides.get(key2).add(pin2.side);
+        }
+      }
+    }
+  }
+  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);
+      }
+    }
+  }
+  for (const [connKey, connected] of Object.entries(
+    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);
+      }
+    }
+  }
+  return {
+    pinToNetworkMap,
+    filteredPins
+  };
+}
+
+// lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
 var SingleInnerPartitionPackingSolver = class extends BaseSolver {
   inputProblem;
   layout = null;
-  phasedPackSolver = null;
   constructor(inputProblem) {
     super();
     this.inputProblem = inputProblem;
   }
   _step() {
     try {
-      if (!this.phasedPackSolver) {
+      if (!this.activeSubSolver) {
         const packInput = this.createPackInput();
-        this.phasedPackSolver = new PhasedPackSolver(packInput);
-        this.activeSubSolver = this.phasedPackSolver;
+        this.activeSubSolver = new PackSolver2(packInput);
+        this.activeSubSolver = this.activeSubSolver;
       }
-      this.phasedPackSolver.step();
-      if (this.phasedPackSolver.failed) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.failed) {
         this.failed = true;
-        this.error = `PhasedPackSolver failed: ${this.phasedPackSolver.error}`;
+        this.error = `PackSolver2 failed: ${this.activeSubSolver.error}`;
         return;
       }
-      if (this.phasedPackSolver.solved) {
+      if (this.activeSubSolver.solved) {
         this.layout = this.createLayoutFromPackingResult(
-          this.phasedPackSolver.getResult()
+          this.activeSubSolver.packedComponents
         );
         this.solved = true;
         this.activeSubSolver = null;
@@ -488,32 +584,7 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
     }
   }
   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 { pinToNetworkMap } = createFilteredNetworkMapping(this.inputProblem);
     const packComponents = Object.entries(this.inputProblem.chipMap).map(
       ([chipId, chip]) => {
         const pads = [];
@@ -572,8 +643,8 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
     };
   }
   visualize() {
-    if (this.phasedPackSolver && !this.solved) {
-      return this.phasedPackSolver.visualize();
+    if (this.activeSubSolver && !this.solved) {
+      return this.activeSubSolver.visualize();
     }
     if (!this.layout) {
       return super.visualize();
@@ -653,12 +724,12 @@ var PackInnerPartitionsSolver = class extends BaseSolver {
 };
 
 // lib/solvers/PartitionPackingSolver/PartitionPackingSolver.ts
-import { PhasedPackSolver as PhasedPackSolver2 } from "calculate-packing";
+import { PackSolver2 as PackSolver22 } from "calculate-packing";
 var PartitionPackingSolver = class extends BaseSolver {
   packedPartitions;
   inputProblem;
   finalLayout = null;
-  phasedPackSolver = null;
+  packSolver2 = null;
   constructor(input) {
     super();
     this.packedPartitions = input.packedPartitions;
@@ -680,20 +751,20 @@ var PartitionPackingSolver = class extends BaseSolver {
         return;
       }
       const partitionGroups = this.organizePackedPartitions();
-      if (!this.phasedPackSolver) {
+      if (!this.packSolver2) {
         const packInput = this.createPackInput(partitionGroups);
-        this.phasedPackSolver = new PhasedPackSolver2(packInput);
-        this.activeSubSolver = this.phasedPackSolver;
+        this.packSolver2 = new PackSolver22(packInput);
+        this.activeSubSolver = this.packSolver2;
       }
-      this.phasedPackSolver.step();
-      if (this.phasedPackSolver.failed) {
+      this.packSolver2.step();
+      if (this.packSolver2.failed) {
         this.failed = true;
-        this.error = `PhasedPackSolver failed: ${this.phasedPackSolver.error}`;
+        this.error = `PackSolver2 failed: ${this.packSolver2.error}`;
         return;
       }
-      if (this.phasedPackSolver.solved) {
+      if (this.packSolver2.solved) {
         const packedLayout = this.applyPackingResult(
-          this.phasedPackSolver.getResult(),
+          this.packSolver2.packedComponents,
           partitionGroups
         );
         this.finalLayout = packedLayout;
@@ -876,8 +947,8 @@ var PartitionPackingSolver = class extends BaseSolver {
     };
   }
   visualize() {
-    if (this.phasedPackSolver && !this.solved) {
-      return this.phasedPackSolver.visualize();
+    if (this.packSolver2 && !this.solved) {
+      return this.packSolver2.visualize();
     }
     if (!this.finalLayout) {
       return super.visualize();
@@ -979,7 +1050,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
   constructor(inputProblem) {
     super();
     this.inputProblem = inputProblem;
-    this.MAX_ITERATIONS = 1e3;
+    this.MAX_ITERATIONS = 1e6;
     this.startTimeOfPhase = {};
     this.endTimeOfPhase = {};
     this.timeSpentOnPhase = {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "files": [
     "dist"
   ],
@@ -10,7 +10,8 @@
     "start": "cosmos",
     "build": "tsup-node --format esm --dts --clean ./lib/index.ts",
     "format": "biome format --write .",
-    "format:check": "biome format ."
+    "format:check": "biome format .",
+    "build:site": "cosmos-export"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.1.3",
@@ -20,7 +21,7 @@
     "@tscircuit/schematic-viewer": "^2.0.26",
     "@types/bun": "latest",
     "bpc-graph": "^0.0.66",
-    "calculate-packing": "^0.0.19",
+    "calculate-packing": "^0.0.27",
     "circuit-json": "^0.0.226",
     "graphics-debug": "^0.0.62",
     "react-cosmos": "^7.0.0",