@tscircuit/capacity-autorouter 0.0.16 → 0.0.18

package/README.md

@@ -1,5 +1,7 @@
 # @tscircuit/capacity-autorouter
 
+[View Online Playground](https://unraveller.vercel.app) · [tscircuit docs](https://docs.tscircuit.com)
+
 A high-density PCB autorouter library for node.js and TypeScript projects. Part of the [tscircuit project](https://github.com/tscircuit/tscircuit) · [discord](https://tscircuit.com/join) · [twitter](https://x.com/seveibar) · [try tscircuit online](https://tscircuit.com)
 
 Check out this [short youtube explanation of this autorouter](https://youtu.be/MmTk0806fAo)

package/dist/index.d.ts

@@ -66,6 +66,7 @@ interface CapacityMeshNode {
     width: number;
     height: number;
     layer: string;
+    availableZ: number[];
     _depth?: number;
     _completelyInsideObstacle?: boolean;
     _containsObstacle?: boolean;
@@ -92,6 +93,7 @@ declare class BaseSolver {
     iterations: number;
     progress: number;
     error: string | null;
+    failedSubSolvers?: BaseSolver[];
     /** DO NOT OVERRIDE! Override _step() instead */
     step(): void;
     _step(): void;
@@ -112,6 +114,12 @@ declare class CapacityMeshEdgeSolver extends BaseSolver {
 interface CapacityMeshNodeSolverOptions {
     capacityDepth?: number;
 }
+interface Target {
+    x: number;
+    y: number;
+    connectionName: string;
+    availableZ: number[];
+}
 declare class CapacityMeshNodeSolver extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshNodeSolverOptions;
@@ -119,16 +127,12 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     finishedNodes: CapacityMeshNode[];
     nodeToOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
     MAX_DEPTH: number;
-    targets: Array<{
-        x: number;
-        y: number;
-        connectionName: string;
-    }>;
+    targets: Target[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
     _nextNodeCounter: number;
     getNextNodeId(): string;
     getCapacityFromDepth(depth: number): number;
-    getTargetNameIfNodeContainsTarget(node: CapacityMeshNode): string | null;
+    getTargetIfNodeContainsTarget(node: CapacityMeshNode): Target | null;
     getOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
     /**
      * Checks if the given mesh node overlaps with any obstacle.
@@ -233,6 +237,7 @@ interface NodePortSegment {
         x: number;
         y: number;
     };
+    availableZ: number[];
     connectionNames: string[];
 }
 
@@ -473,7 +478,7 @@ declare class SingleHighDensityRouteSolver extends BaseSolver {
     handleSimpleCases(): void;
     get viaPenaltyDistance(): number;
     isNodeTooCloseToObstacle(node: Node, margin?: number, isVia?: boolean): boolean;
-    isNodeTooCloseToEdge(node: Node): boolean;
+    isNodeTooCloseToEdge(node: Node, isVia?: boolean): boolean;
     doesPathToParentIntersectObstacle(node: Node): boolean;
     computeH(node: Node): number;
     computeG(node: Node): number;
@@ -504,11 +509,12 @@ declare class IntraNodeRouteSolver extends BaseSolver {
     }[];
     totalConnections: number;
     solvedRoutes: HighDensityIntraNodeRoute[];
-    failedSolvers: SingleHighDensityRouteSolver[];
+    failedSubSolvers: SingleHighDensityRouteSolver[];
     hyperParameters: Partial<HighDensityHyperParameters>;
     minDistBetweenEnteringPoints: number;
     activeSolver: SingleHighDensityRouteSolver | null;
     connMap?: ConnectivityMap;
+    get failedSolvers(): SingleHighDensityRouteSolver[];
     constructor(params: {
         nodeWithPortPoints: NodeWithPortPoints;
         colorMap?: Record<string, string>;

package/dist/index.js

@@ -43,6 +43,7 @@ var BaseSolver = class {
   iterations = 0;
   progress = 0;
   error = null;
+  failedSubSolvers;
   /** DO NOT OVERRIDE! Override _step() instead */
   step() {
     if (this.solved) return;
@@ -1092,6 +1093,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
         width: maxWidthHeight,
         height: maxWidthHeight,
         layer: "top",
+        availableZ: [0, 1],
         _depth: 0,
         _containsTarget: true,
         _containsObstacle: true,
@@ -1101,7 +1103,11 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     this.finishedNodes = [];
     this.nodeToOverlappingObstaclesMap = /* @__PURE__ */ new Map();
     this.targets = this.srj.connections.flatMap(
-      (c) => c.pointsToConnect.map((p) => ({ ...p, connectionName: c.name }))
+      (c) => c.pointsToConnect.map((p) => ({
+        ...p,
+        connectionName: c.name,
+        availableZ: p.layer === "top" ? [0] : [1]
+      }))
     );
   }
   unfinishedNodes;
@@ -1117,7 +1123,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
   getCapacityFromDepth(depth) {
     return (this.MAX_DEPTH - depth + 1) ** 2;
   }
-  getTargetNameIfNodeContainsTarget(node) {
+  getTargetIfNodeContainsTarget(node) {
     const overlappingObstacles = this.getOverlappingObstacles(node);
     for (const target of this.targets) {
       const targetObstacle = overlappingObstacles.find(
@@ -1125,11 +1131,11 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
       );
       if (targetObstacle) {
         if (doRectsOverlap(node, targetObstacle)) {
-          return target.connectionName;
+          return target;
         }
       }
       if (target.x >= node.center.x - node.width / 2 && target.x <= node.center.x + node.width / 2 && target.y >= node.center.y - node.height / 2 && target.y <= node.center.y + node.height / 2) {
-        return target.connectionName;
+        return target;
       }
     }
     return null;
@@ -1232,12 +1238,17 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
         width: childNodeSize.width,
         height: childNodeSize.height,
         layer: parent.layer,
+        availableZ: [0, 1],
         _depth: (parent._depth ?? 0) + 1,
         _parent: parent
       };
       childNode._containsObstacle = this.doesNodeOverlapObstacle(childNode);
-      childNode._targetConnectionName = this.getTargetNameIfNodeContainsTarget(childNode) ?? void 0;
-      childNode._containsTarget = Boolean(childNode._targetConnectionName);
+      const target = this.getTargetIfNodeContainsTarget(childNode);
+      if (target) {
+        childNode._targetConnectionName = target.connectionName;
+        childNode.availableZ = target.availableZ;
+        childNode._containsTarget = true;
+      }
       if (childNode._containsObstacle) {
         childNode._completelyInsideObstacle = this.isNodeCompletelyInsideObstacle(childNode);
       }
@@ -1294,16 +1305,6 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
       coordinateSystem: "cartesian",
       title: "Capacity Mesh Visualization"
     };
-    const allNodes = [...this.finishedNodes, ...this.unfinishedNodes];
-    for (const node of allNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: Math.max(node.width - 2, node.width * 0.8),
-        height: Math.max(node.height - 2, node.height * 0.8),
-        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : "rgba(0,0,0,0.1)",
-        label: node.capacityMeshNodeId
-      });
-    }
     for (const obstacle of this.srj.obstacles) {
       graphics.rects.push({
         center: obstacle.center,
@@ -1314,13 +1315,24 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
         label: "obstacle"
       });
     }
+    const allNodes = [...this.finishedNodes, ...this.unfinishedNodes];
+    for (const node of allNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: Math.max(node.width - 2, node.width * 0.8),
+        height: Math.max(node.height - 2, node.height * 0.8),
+        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : "rgba(0,0,0,0.1)",
+        label: `${node.capacityMeshNodeId}
+availableZ: ${node.availableZ.join(",")}`
+      });
+    }
     this.srj.connections.forEach((connection, index) => {
       const color = COLORS[index % COLORS.length];
       for (const pt of connection.pointsToConnect) {
         graphics.points.push({
           x: pt.x,
           y: pt.y,
-          label: `conn-${index}`,
+          label: `conn-${index} (${pt.layer})`,
           color
         });
       }
@@ -1390,11 +1402,16 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
         const adjNode = this.nodeMap.get(adjNodeId);
         if (!adjNode) continue;
         const segment = findOverlappingSegment(node, adjNode);
+        const mutuallyAvailableZ = adjNode.availableZ.filter(
+          (z) => node.availableZ.includes(z)
+        );
+        if (mutuallyAvailableZ.length === 0) continue;
         const portSegment = {
           capacityMeshNodeId: nodeId,
           start: segment.start,
           end: segment.end,
-          connectionNames: [path.connectionName]
+          connectionNames: [path.connectionName],
+          availableZ: mutuallyAvailableZ
         };
         nodePortSegments.push(portSegment);
       }
@@ -1413,7 +1430,7 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
       const node = this.nodeMap.get(nodeId);
       segments.forEach((segment) => {
         const isVertical = segment.start.x === segment.end.x;
-        const THICKNESS = 0.5 / segment.connectionNames.length;
+        const THICKNESS = 0.1 / segment.connectionNames.length;
         for (let i = 0; i < segment.connectionNames.length; i++) {
           const offsetAmount = (i / (segment.connectionNames.length - 1 + 1e-6) - 0.5) * THICKNESS;
           const offset = {
@@ -1435,7 +1452,8 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
               this.colorMap[segment.connectionNames[i]],
               0.6
             ),
-            label: `${nodeId}: ${segment.connectionNames.join(", ")}`
+            label: `${nodeId}: ${segment.connectionNames.join(", ")}
+availableZ: ${segment.availableZ.join(",")}`
           });
         }
       });
@@ -1536,7 +1554,7 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
         const center = {
           x: (seg.start.x + seg.end.x) / 2,
           y: (seg.start.y + seg.end.y) / 2,
-          z: 0
+          z: seg.availableZ[0]
         };
         seg.assignedPoints = [
           { connectionName: seg.connectionNames[0], point: center }
@@ -1563,7 +1581,7 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
         points.push({
           x: candidate.start.x + dx * fraction,
           y: candidate.start.y + dy * fraction,
-          z: 0
+          z: candidate.availableZ[0]
         });
       }
       ;
@@ -1809,9 +1827,15 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     }
     return false;
   }
-  isNodeTooCloseToEdge(node) {
-    const viaRadius = this.viaDiameter / 2;
-    return node.x < this.bounds.minX + viaRadius || node.x > this.bounds.maxX - viaRadius || node.y < this.bounds.minY + viaRadius || node.y > this.bounds.maxY - viaRadius;
+  isNodeTooCloseToEdge(node, isVia) {
+    const margin = isVia ? this.viaDiameter / 2 : this.obstacleMargin;
+    const tooClose = node.x < this.bounds.minX + margin || node.x > this.bounds.maxX - margin || node.y < this.bounds.minY + margin || node.y > this.bounds.maxY - margin;
+    if (tooClose && !isVia) {
+      if (distance(node, this.B) < margin * 2) {
+        return false;
+      }
+    }
+    return tooClose;
   }
   doesPathToParentIntersectObstacle(node) {
     const parent = node.parent;
@@ -1865,6 +1889,10 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
           this.exploredNodes.add(neighborKey);
           continue;
         }
+        if (this.isNodeTooCloseToEdge(neighbor, false)) {
+          this.exploredNodes.add(neighborKey);
+          continue;
+        }
         if (this.doesPathToParentIntersectObstacle(neighbor)) {
           this.debug_nodePathToParentIntersectsObstacle.add(neighborKey);
           this.exploredNodes.add(neighborKey);
@@ -1883,9 +1911,9 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     };
     if (!this.exploredNodes.has(this.getNodeKey(viaNeighbor)) && !this.isNodeTooCloseToObstacle(
       viaNeighbor,
-      this.viaDiameter / 2 + this.obstacleMargin,
+      this.viaDiameter / 2 + this.obstacleMargin / 2,
       true
-    ) && !this.isNodeTooCloseToEdge(viaNeighbor)) {
+    ) && !this.isNodeTooCloseToEdge(viaNeighbor, true)) {
       viaNeighbor.g = this.computeG(viaNeighbor);
       viaNeighbor.h = this.computeH(viaNeighbor);
       viaNeighbor.f = this.computeF(viaNeighbor.g, viaNeighbor.h);
@@ -1977,13 +2005,15 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     graphics.points.push({
       x: this.A.x,
       y: this.A.y,
-      label: "Input A",
+      label: `Input A
+z: ${this.A.z}`,
       color: "orange"
     });
     graphics.points.push({
       x: this.B.x,
       y: this.B.y,
-      label: "Input B",
+      label: `Input B
+z: ${this.B.z}`,
       color: "orange"
     });
     graphics.lines.push({
@@ -2219,11 +2249,15 @@ var IntraNodeRouteSolver = class extends BaseSolver {
   unsolvedConnections;
   totalConnections;
   solvedRoutes;
-  failedSolvers;
+  failedSubSolvers;
   hyperParameters;
   minDistBetweenEnteringPoints;
   activeSolver = null;
   connMap;
+  // Legacy compat
+  get failedSolvers() {
+    return this.failedSubSolvers;
+  }
   constructor(params) {
     const { nodeWithPortPoints, colorMap } = params;
     super();
@@ -2231,7 +2265,7 @@ var IntraNodeRouteSolver = class extends BaseSolver {
     this.colorMap = colorMap ?? {};
     this.solvedRoutes = [];
     this.hyperParameters = params.hyperParameters ?? {};
-    this.failedSolvers = [];
+    this.failedSubSolvers = [];
     this.connMap = params.connMap;
     const unsolvedConnectionsMap = /* @__PURE__ */ new Map();
     for (const { connectionName, x, y, z } of nodeWithPortPoints.portPoints) {
@@ -2292,9 +2326,9 @@ var IntraNodeRouteSolver = class extends BaseSolver {
         this.solvedRoutes.push(this.activeSolver.solvedPath);
         this.activeSolver = null;
       } else if (this.activeSolver.failed) {
-        this.failedSolvers.push(this.activeSolver);
+        this.failedSubSolvers.push(this.activeSolver);
         this.activeSolver = null;
-        this.error = this.failedSolvers.map((s) => s.error).join("\n");
+        this.error = this.failedSubSolvers.map((s) => s.error).join("\n");
         this.failed = true;
       }
       return;
@@ -2302,7 +2336,7 @@ var IntraNodeRouteSolver = class extends BaseSolver {
     const unsolvedConnection = this.unsolvedConnections.pop();
     this.progress = this.computeProgress();
     if (!unsolvedConnection) {
-      this.solved = this.failedSolvers.length === 0;
+      this.solved = this.failedSubSolvers.length === 0;
       return;
     }
     if (unsolvedConnection.points.length === 1) {
@@ -2373,6 +2407,20 @@ var IntraNodeRouteSolver = class extends BaseSolver {
         }
       }
     }
+    const bounds = getBoundsFromNodeWithPortPoints(this.nodeWithPortPoints);
+    const { minX, minY, maxX, maxY } = bounds;
+    graphics.lines.push({
+      points: [
+        { x: minX, y: minY },
+        { x: maxX, y: minY },
+        { x: maxX, y: maxY },
+        { x: minX, y: maxY },
+        { x: minX, y: minY }
+      ],
+      strokeColor: "rgba(255, 0, 0, 0.25)",
+      strokeDash: "4 4",
+      layer: "border"
+    });
     return graphics;
   }
 };
@@ -3269,6 +3317,7 @@ var CapacityNodeTargetMerger = class extends BaseSolver {
       width: bounds.maxX - bounds.minX,
       height: bounds.maxY - bounds.minY,
       layer: connectedNodes[0].layer,
+      availableZ: connectedNodes[0].availableZ,
       _completelyInsideObstacle: false,
       _containsObstacle: true,
       _containsTarget: true,
@@ -3527,11 +3576,6 @@ var CapacitySegmentPointOptimizer = class extends BaseSolver {
     const segments = segmentIds.map(
       (segmentId) => this.currentMutatedSegments.get(segmentId)
     );
-    const points = segments.flatMap((s) => s.assignedPoints);
-    if (points.length <= 2) {
-      if (points.length <= 1) return 0;
-      return 0;
-    }
     const {
       numEntryExitLayerChanges,
       numSameLayerCrossings,
@@ -3606,10 +3650,6 @@ var CapacitySegmentPointOptimizer = class extends BaseSolver {
         point2Index: randomPointIndex2
       };
     }
-    const nodeIds = this.segmentIdToNodeIds.get(segment.nodePortSegmentId);
-    if (nodeIds?.some((nodeId) => this.nodesThatCantFitVias.has(nodeId))) {
-      return null;
-    }
     const randomPointIndex = Math.floor(
       this.random() * segment.assignedPoints.length
     );
@@ -3815,9 +3855,7 @@ var CapacitySegmentPointOptimizer = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    const op = this.getRandomCombinedOperationNearNode(
-      this.getRandomWeightedNodeId()
-    );
+    const op = this.getRandomCombinedOperationOnSingleNode();
     this.lastCreatedOperation = op;
     this.applyOperation(op);
     const {
@@ -4689,6 +4727,7 @@ var convertSrjToGraphicsObject = (srj) => {
               { x: routePoint.x, y: routePoint.y },
               { x: nextRoutePoint.x, y: nextRoutePoint.y }
             ],
+            strokeWidth: 0.15,
             strokeColor: safeTransparentize(
               {
                 top: "red",