@tscircuit/core 0.0.619 → 0.0.621

package/dist/index.d.ts

@@ -1126,6 +1126,7 @@ declare class Group<Props extends z.ZodType<any, any, any> = typeof groupProps>
     _getSchematicLayoutMode(): "match-adapt" | "flex" | "grid" | "relative";
     doInitialSchematicLayout(): void;
     _doInitialSchematicLayoutMatchAdapt(): void;
+    _doInitialSchematicLayoutMatchpack(): void;
     _doInitialSchematicLayoutGrid(): void;
     _getPcbLayoutMode(): "grid" | "flex" | "match-adapt" | "pack" | "none";
     doInitialPcbLayout(): void;

package/dist/index.js

@@ -7184,7 +7184,7 @@ var CapacityMeshAutorouter = class {
 
 // lib/components/primitive-components/Group/Group.ts
 import "circuit-json";
-import Debug7 from "debug";
+import Debug8 from "debug";
 import "zod";
 
 // lib/components/primitive-components/TraceHint.ts
@@ -7944,6 +7944,295 @@ function Group_doInitialSchematicLayoutMatchAdapt(group) {
   }
 }
 
+// lib/components/primitive-components/Group/Group_doInitialSchematicLayoutMatchPack.ts
+import {
+  getCircuitJsonTree
+} from "@tscircuit/circuit-json-util";
+import { LayoutPipelineSolver } from "@tscircuit/matchpack";
+import Debug6 from "debug";
+var debug5 = Debug6("Group_doInitialSchematicLayoutMatchpack");
+function rotateDirection(direction, degrees) {
+  const directions = [
+    "up",
+    "right",
+    "down",
+    "left"
+  ];
+  const currentIndex = directions.indexOf(direction);
+  if (currentIndex === -1) return direction;
+  const steps = Math.round(degrees / 90);
+  const newIndex = (currentIndex + steps) % 4;
+  return directions[newIndex < 0 ? newIndex + 4 : newIndex];
+}
+function convertTreeToInputProblem(tree, db) {
+  const problem = {
+    chipMap: {},
+    chipPinMap: {},
+    groupMap: {},
+    groupPinMap: {},
+    netMap: {},
+    pinStrongConnMap: {},
+    netConnMap: {},
+    chipGap: 0.4,
+    partitionGap: 1.2
+  };
+  tree.childNodes.forEach((child, index) => {
+    if (child.nodeType === "component" && child.sourceComponent) {
+      const chipId = child.sourceComponent.name || `chip_${index}`;
+      const schematicComponent = db.schematic_component.getWhere({
+        source_component_id: child.sourceComponent.source_component_id
+      });
+      if (!schematicComponent) return;
+      problem.chipMap[chipId] = {
+        chipId,
+        pins: [],
+        size: {
+          x: schematicComponent.size?.width || 1,
+          y: schematicComponent.size?.height || 1
+        }
+        // TODO determine availableRotations based on the component._parsedProps.schOrientation and component._parsedProps.schRotation (if explicitly defined)
+        // availableRotations: [0, 90, 180, 270]
+      };
+      const ports = db.schematic_port.list({
+        schematic_component_id: schematicComponent.schematic_component_id
+      });
+      for (const port of ports) {
+        const sourcePort = db.source_port.get(port.source_port_id);
+        if (!sourcePort) continue;
+        const pinId = `${chipId}.${sourcePort.pin_number || sourcePort.name || port.schematic_port_id}`;
+        problem.chipMap[chipId].pins.push(pinId);
+        let side = "y+";
+        switch (port.facing_direction) {
+          case "up":
+            side = "y+";
+            break;
+          case "down":
+            side = "y-";
+            break;
+          case "left":
+            side = "x-";
+            break;
+          case "right":
+            side = "x+";
+            break;
+        }
+        problem.chipPinMap[pinId] = {
+          pinId,
+          offset: {
+            x: (port.center?.x || 0) - (schematicComponent.center.x || 0),
+            y: (port.center?.y || 0) - (schematicComponent.center.y || 0)
+          },
+          side
+        };
+      }
+    } else if (child.nodeType === "group" && child.sourceGroup) {
+      const groupId = child.sourceGroup.name || `group_${index}`;
+      const schematicGroup = db.schematic_group?.getWhere?.({
+        source_group_id: child.sourceGroup.source_group_id
+      });
+      if (schematicGroup) {
+        problem.chipMap[groupId] = {
+          chipId: groupId,
+          pins: [],
+          size: {
+            x: schematicGroup.size?.width || 2,
+            y: schematicGroup.size?.height || 2
+          }
+        };
+      }
+    }
+  });
+  const sourceTraces = db.source_trace.list();
+  const sourceNets = db.source_net.list();
+  for (const net of sourceNets) {
+    problem.netMap[net.name || net.source_net_id] = {
+      netId: net.name || net.source_net_id
+    };
+  }
+  for (const trace of sourceTraces) {
+    const connectedPorts = trace.connected_source_port_ids || [];
+    const connectedNets = trace.connected_source_net_ids || [];
+    const relevantPins = [];
+    for (const portId of connectedPorts) {
+      const sourcePort = db.source_port.get(portId);
+      if (!sourcePort) continue;
+      for (const [chipId, chip] of Object.entries(problem.chipMap)) {
+        const chipSourceComponent = tree.childNodes.find(
+          (n) => n.sourceComponent?.name === chipId
+        )?.sourceComponent;
+        if (chipSourceComponent) {
+          const isPortInComponent = db.source_port.list({
+            source_component_id: chipSourceComponent.source_component_id
+          }).some((p) => p.source_port_id === portId);
+          if (isPortInComponent) {
+            const pinNumber = sourcePort.pin_number || sourcePort.name;
+            const expectedPinId = `${chipId}.${pinNumber}`;
+            if (chip.pins.includes(expectedPinId)) {
+              relevantPins.push(expectedPinId);
+            } else {
+              debug5(
+                `Warning: Could not find pin ${expectedPinId} in chip ${chipId}`
+              );
+            }
+          }
+        }
+      }
+    }
+    if (relevantPins.length === 2 && connectedNets.length === 0) {
+      const [pin1, pin2] = relevantPins;
+      problem.pinStrongConnMap[`${pin1}-${pin2}`] = true;
+      problem.pinStrongConnMap[`${pin2}-${pin1}`] = true;
+    }
+    for (const pinId of relevantPins) {
+      for (const netId of connectedNets) {
+        const net = db.source_net.get(netId);
+        const netName = net?.name || netId;
+        problem.netConnMap[`${pinId}-${netName}`] = true;
+      }
+    }
+  }
+  return problem;
+}
+function Group_doInitialSchematicLayoutMatchPack(group) {
+  const { db } = group.root;
+  const tree = getCircuitJsonTree(db.toArray(), {
+    source_group_id: group.source_group_id
+  });
+  debug5("Converting circuit tree to InputProblem...");
+  const inputProblem = convertTreeToInputProblem(tree, db);
+  debug5("InputProblem:", JSON.stringify(inputProblem, null, 2));
+  const solver = new LayoutPipelineSolver(inputProblem);
+  debug5("Starting LayoutPipelineSolver...");
+  if (debug5.enabled && global.debugGraphics) {
+    const initialViz = solver.visualize();
+    global.debugGraphics.push({
+      ...initialViz,
+      title: `matchpack-initial-${group.name}`
+    });
+  }
+  solver.solve();
+  debug5(`Solver completed in ${solver.iterations} iterations`);
+  debug5(`Solved: ${solver.solved}, Failed: ${solver.failed}`);
+  if (solver.failed) {
+    debug5(`Solver failed with error: ${solver.error}`);
+    throw new Error(`Matchpack layout solver failed: ${solver.error}`);
+  }
+  const outputLayout = solver.getOutputLayout();
+  debug5("OutputLayout:", JSON.stringify(outputLayout, null, 2));
+  if (debug5.enabled && global.debugGraphics) {
+    const finalViz = solver.visualize();
+    global.debugGraphics.push({
+      ...finalViz,
+      title: `matchpack-final-${group.name}`
+    });
+  }
+  const overlaps = solver.checkForOverlaps(outputLayout);
+  if (overlaps.length > 0) {
+    debug5(`Warning: Found ${overlaps.length} overlapping components:`);
+    for (const overlap of overlaps) {
+      debug5(
+        `  ${overlap.chip1} overlaps ${overlap.chip2} (area: ${overlap.overlapArea})`
+      );
+    }
+  }
+  const groupOffset = group._getGlobalSchematicPositionBeforeLayout();
+  debug5(`Group offset: x=${groupOffset.x}, y=${groupOffset.y}`);
+  for (const [chipId, placement] of Object.entries(
+    outputLayout.chipPlacements
+  )) {
+    const treeNode = tree.childNodes.find((child) => {
+      if (child.nodeType === "component" && child.sourceComponent) {
+        return child.sourceComponent.name === chipId;
+      }
+      if (child.nodeType === "group" && child.sourceGroup) {
+        return child.sourceGroup.name === chipId;
+      }
+      return false;
+    });
+    if (!treeNode) {
+      debug5(`Warning: No tree node found for chip: ${chipId}`);
+      continue;
+    }
+    const newCenter = {
+      x: placement.x + groupOffset.x,
+      y: placement.y + groupOffset.y
+    };
+    if (treeNode.nodeType === "component" && treeNode.sourceComponent) {
+      const schematicComponent = db.schematic_component.getWhere({
+        source_component_id: treeNode.sourceComponent.source_component_id
+      });
+      if (schematicComponent) {
+        debug5(`Moving component ${chipId} to (${newCenter.x}, ${newCenter.y})`);
+        const ports = db.schematic_port.list({
+          schematic_component_id: schematicComponent.schematic_component_id
+        });
+        const texts = db.schematic_text.list({
+          schematic_component_id: schematicComponent.schematic_component_id
+        });
+        const positionDelta = {
+          x: newCenter.x - schematicComponent.center.x,
+          y: newCenter.y - schematicComponent.center.y
+        };
+        for (const port of ports) {
+          port.center.x += positionDelta.x;
+          port.center.y += positionDelta.y;
+        }
+        for (const text of texts) {
+          text.position.x += positionDelta.x;
+          text.position.y += positionDelta.y;
+        }
+        schematicComponent.center = newCenter;
+        if (placement.ccwRotationDegrees !== 0) {
+          debug5(
+            `Component ${chipId} has rotation: ${placement.ccwRotationDegrees}\xB0`
+          );
+          const angleRad = placement.ccwRotationDegrees * Math.PI / 180;
+          const cos = Math.cos(angleRad);
+          const sin = Math.sin(angleRad);
+          for (const port of ports) {
+            const dx = port.center.x - newCenter.x;
+            const dy = port.center.y - newCenter.y;
+            const rotatedDx = dx * cos - dy * sin;
+            const rotatedDy = dx * sin + dy * cos;
+            port.center.x = newCenter.x + rotatedDx;
+            port.center.y = newCenter.y + rotatedDy;
+            const originalDirection = port.facing_direction || "right";
+            port.facing_direction = rotateDirection(
+              originalDirection,
+              placement.ccwRotationDegrees
+            );
+          }
+          for (const text of texts) {
+            const dx = text.position.x - newCenter.x;
+            const dy = text.position.y - newCenter.y;
+            const rotatedDx = dx * cos - dy * sin;
+            const rotatedDy = dx * sin + dy * cos;
+            text.position.x = newCenter.x + rotatedDx;
+            text.position.y = newCenter.y + rotatedDy;
+          }
+          if (schematicComponent.symbol_name) {
+            const schematicSymbolDirection = schematicComponent.symbol_name.match(/_(right|left|up|down)$/);
+            if (schematicSymbolDirection) {
+              schematicComponent.symbol_name = schematicComponent.symbol_name.replace(
+                schematicSymbolDirection[0],
+                `_${rotateDirection(schematicSymbolDirection[1], placement.ccwRotationDegrees)}`
+              );
+            }
+          }
+        }
+      }
+    } else if (treeNode.nodeType === "group" && treeNode.sourceGroup) {
+      const schematicGroup = db.schematic_group?.getWhere?.({
+        source_group_id: treeNode.sourceGroup.source_group_id
+      });
+      if (schematicGroup) {
+        debug5(`Moving group ${chipId} to (${newCenter.x}, ${newCenter.y})`);
+      }
+    }
+  }
+  debug5("Matchpack layout completed successfully");
+}
+
 // lib/components/primitive-components/Group/Group_doInitialSourceAddConnectivityMapKey.ts
 import { ConnectivityMap as ConnectivityMap2 } from "circuit-json-to-connectivity-map";
 function Group_doInitialSourceAddConnectivityMapKey(group) {
@@ -8351,8 +8640,8 @@ import {
   transformPCBElements as transformPCBElements2
 } from "@tscircuit/circuit-json-util";
 import { translate as translate6, rotate as rotate2, compose as compose4 } from "transformation-matrix";
-import Debug6 from "debug";
-var debug5 = Debug6("Group_doInitialPcbLayoutPack");
+import Debug7 from "debug";
+var debug6 = Debug7("Group_doInitialPcbLayoutPack");
 var Group_doInitialPcbLayoutPack = (group) => {
   const { db } = group.root;
   const { _parsedProps: props } = group;
@@ -8372,12 +8661,13 @@ var Group_doInitialPcbLayoutPack = (group) => {
         source_group_id: group.source_group_id
       })
     ),
+    // @ts-expect-error we're missing some pack order strategies
     orderStrategy: packOrderStrategy ?? "largest_to_smallest",
-    placementStrategy: packPlacementStrategy ?? "shortest_connection_along_outline",
+    placementStrategy: packPlacementStrategy ?? "minimum_sum_squared_distance_to_network",
     minGap: gapMm
   };
   const packOutput = pack(packInput);
-  if (debug5.enabled) {
+  if (debug6.enabled) {
     const graphics = getGraphicsFromPackOutput(packOutput);
     graphics.title = `packOutput-${group.name}`;
     global.debugGraphics?.push(graphics);
@@ -8390,7 +8680,7 @@ var Group_doInitialPcbLayoutPack = (group) => {
       const transformMatrix2 = compose4(
         group._computePcbGlobalTransformBeforeLayout(),
         translate6(center.x, center.y),
-        rotate2(ccwRotationOffset || 0),
+        rotate2((ccwRotationOffset || 0) * Math.PI / 180),
         translate6(-originalCenter2.x, -originalCenter2.y)
       );
       const related = db.toArray().filter(
@@ -8416,7 +8706,7 @@ var Group_doInitialPcbLayoutPack = (group) => {
 
 // lib/components/primitive-components/Group/Group_doInitialPcbLayoutFlex.ts
 import {
-  getCircuitJsonTree,
+  getCircuitJsonTree as getCircuitJsonTree2,
   repositionPcbComponentTo,
   repositionPcbGroupTo,
   getMinimumFlexContainer
@@ -8450,7 +8740,7 @@ var getSizeOfTreeNodeChild = (db, child) => {
 var Group_doInitialPcbLayoutFlex = (group) => {
   const { db } = group.root;
   const { _parsedProps: props } = group;
-  const tree = getCircuitJsonTree(db.toArray(), {
+  const tree = getCircuitJsonTree2(db.toArray(), {
     source_group_id: group.source_group_id
   });
   const rawJustify = props.pcbJustifyContent ?? props.justifyContent;
@@ -8746,20 +9036,20 @@ var Group = class extends NormalComponent {
     return false;
   }
   _hasTracesToRoute() {
-    const debug6 = Debug7("tscircuit:core:_hasTracesToRoute");
+    const debug7 = Debug8("tscircuit:core:_hasTracesToRoute");
     const traces = this.selectAll("trace");
-    debug6(`[${this.getString()}] has ${traces.length} traces to route`);
+    debug7(`[${this.getString()}] has ${traces.length} traces to route`);
     return traces.length > 0;
   }
   async _runEffectMakeHttpAutoroutingRequest() {
     const { db } = this.root;
-    const debug6 = Debug7("tscircuit:core:_runEffectMakeHttpAutoroutingRequest");
+    const debug7 = Debug8("tscircuit:core:_runEffectMakeHttpAutoroutingRequest");
     const props = this._parsedProps;
     const autorouterConfig = this._getAutorouterConfig();
     const serverUrl = autorouterConfig.serverUrl;
     const serverMode = autorouterConfig.serverMode;
     const fetchWithDebug = (url, options) => {
-      debug6("fetching", url);
+      debug7("fetching", url);
       if (options.headers) {
         options.headers["Tscircuit-Core-Version"] = this.root?.getCoreVersion();
       }
@@ -8875,15 +9165,15 @@ var Group = class extends NormalComponent {
   async _runLocalAutorouting() {
     const { db } = this.root;
     const props = this._parsedProps;
-    const debug6 = Debug7("tscircuit:core:_runLocalAutorouting");
-    debug6(`[${this.getString()}] starting local autorouting`);
+    const debug7 = Debug8("tscircuit:core:_runLocalAutorouting");
+    debug7(`[${this.getString()}] starting local autorouting`);
     const autorouterConfig = this._getAutorouterConfig();
     const { simpleRouteJson } = getSimpleRouteJsonFromCircuitJson({
       db,
       minTraceWidth: this.props.autorouter?.minTraceWidth ?? 0.15,
       subcircuit_id: this.subcircuit_id
     });
-    if (debug6.enabled) {
+    if (debug7.enabled) {
       const graphicsObject = convertSrjToGraphicsObject(
         simpleRouteJson
       );
@@ -8908,11 +9198,11 @@ var Group = class extends NormalComponent {
     const routingPromise = new Promise(
       (resolve, reject) => {
         autorouter.on("complete", (event) => {
-          debug6(`[${this.getString()}] local autorouting complete`);
+          debug7(`[${this.getString()}] local autorouting complete`);
           resolve(event.traces);
         });
         autorouter.on("error", (event) => {
-          debug6(
+          debug7(
             `[${this.getString()}] local autorouting error: ${event.error.message}`
           );
           reject(event.error);
@@ -8969,30 +9259,30 @@ var Group = class extends NormalComponent {
     }
   }
   doInitialPcbTraceRender() {
-    const debug6 = Debug7("tscircuit:core:doInitialPcbTraceRender");
+    const debug7 = Debug8("tscircuit:core:doInitialPcbTraceRender");
     if (!this.isSubcircuit) return;
     if (this.root?.pcbDisabled) return;
     if (this.getInheritedProperty("routingDisabled")) return;
     if (this._shouldUseTraceByTraceRouting()) return;
     if (!this._areChildSubcircuitsRouted()) {
-      debug6(
+      debug7(
         `[${this.getString()}] child subcircuits are not routed, skipping async autorouting until subcircuits routed`
       );
       return;
     }
-    debug6(
+    debug7(
       `[${this.getString()}] no child subcircuits to wait for, initiating async routing`
     );
     if (!this._hasTracesToRoute()) return;
     this._startAsyncAutorouting();
   }
   updatePcbTraceRender() {
-    const debug6 = Debug7("tscircuit:core:updatePcbTraceRender");
-    debug6(`[${this.getString()}] updating...`);
+    const debug7 = Debug8("tscircuit:core:updatePcbTraceRender");
+    debug7(`[${this.getString()}] updating...`);
     if (!this.isSubcircuit) return;
     if (this._shouldRouteAsync() && this._hasTracesToRoute() && !this._hasStartedAsyncAutorouting) {
       if (this._areChildSubcircuitsRouted()) {
-        debug6(
+        debug7(
           `[${this.getString()}] child subcircuits are now routed, starting async autorouting`
         );
         this._startAsyncAutorouting();
@@ -9003,14 +9293,14 @@ var Group = class extends NormalComponent {
     if (this._shouldUseTraceByTraceRouting()) return;
     const { db } = this.root;
     if (this._asyncAutoroutingResult.output_simple_route_json) {
-      debug6(
+      debug7(
         `[${this.getString()}] updating PCB traces from simple route json (${this._asyncAutoroutingResult.output_simple_route_json.traces?.length} traces)`
       );
       this._updatePcbTraceRenderFromSimpleRouteJson();
       return;
     }
     if (this._asyncAutoroutingResult.output_pcb_traces) {
-      debug6(
+      debug7(
         `[${this.getString()}] updating PCB traces from ${this._asyncAutoroutingResult.output_pcb_traces.length} traces`
       );
       this._updatePcbTraceRenderFromPcbTraces();
@@ -9116,7 +9406,7 @@ var Group = class extends NormalComponent {
     const props = this._parsedProps;
     const schematicLayoutMode = this._getSchematicLayoutMode();
     if (schematicLayoutMode === "match-adapt") {
-      this._doInitialSchematicLayoutMatchAdapt();
+      this._doInitialSchematicLayoutMatchpack();
     }
     if (schematicLayoutMode === "grid") {
       this._doInitialSchematicLayoutGrid();
@@ -9126,6 +9416,9 @@ var Group = class extends NormalComponent {
   _doInitialSchematicLayoutMatchAdapt() {
     Group_doInitialSchematicLayoutMatchAdapt(this);
   }
+  _doInitialSchematicLayoutMatchpack() {
+    Group_doInitialSchematicLayoutMatchPack(this);
+  }
   _doInitialSchematicLayoutGrid() {
     Group_doInitialSchematicLayoutGrid(this);
   }
@@ -11752,7 +12045,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.618",
+  version: "0.0.620",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -11814,7 +12107,8 @@ var package_default = {
     "react-dom": "^19.1.0",
     "schematic-symbols": "^0.0.180",
     "ts-expect": "^1.3.0",
-    tsup: "^8.2.4"
+    tsup: "^8.2.4",
+    "@tscircuit/matchpack": "^0.0.4"
   },
   peerDependencies: {
     "@tscircuit/capacity-autorouter": "*",
@@ -11829,6 +12123,7 @@ var package_default = {
     "@tscircuit/schematic-corpus": "*",
     "circuit-json-to-bpc": "*",
     "bpc-graph": "*",
+    "@tscircuit/matchpack": "*",
     "circuit-json": "*",
     "circuit-json-to-connectivity-map": "*",
     "schematic-symbols": "*",
@@ -11837,7 +12132,7 @@ var package_default = {
   dependencies: {
     "@flatten-js/core": "^1.6.2",
     "@lume/kiwi": "^0.4.3",
-    "calculate-packing": "0.0.9",
+    "calculate-packing": "0.0.17",
     "css-select": "5.1.0",
     "format-si-unit": "^0.0.3",
     nanoid: "^5.0.7",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.619",
+  "version": "0.0.621",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -63,7 +63,8 @@
     "react-dom": "^19.1.0",
     "schematic-symbols": "^0.0.180",
     "ts-expect": "^1.3.0",
-    "tsup": "^8.2.4"
+    "tsup": "^8.2.4",
+    "@tscircuit/matchpack": "^0.0.4"
   },
   "peerDependencies": {
     "@tscircuit/capacity-autorouter": "*",
@@ -78,6 +79,7 @@
     "@tscircuit/schematic-corpus": "*",
     "circuit-json-to-bpc": "*",
     "bpc-graph": "*",
+    "@tscircuit/matchpack": "*",
     "circuit-json": "*",
     "circuit-json-to-connectivity-map": "*",
     "schematic-symbols": "*",
@@ -86,7 +88,7 @@
   "dependencies": {
     "@flatten-js/core": "^1.6.2",
     "@lume/kiwi": "^0.4.3",
-    "calculate-packing": "0.0.9",
+    "calculate-packing": "0.0.17",
     "css-select": "5.1.0",
     "format-si-unit": "^0.0.3",
     "nanoid": "^5.0.7",