@tscircuit/capacity-autorouter 0.0.20 → 0.0.21

package/dist/index.d.ts

@@ -18,6 +18,7 @@ interface SimpleRouteJson {
 interface Obstacle {
     type: "rect";
     layers: string[];
+    zLayers?: number[];
     center: {
         x: number;
         y: number;
@@ -72,6 +73,7 @@ interface CapacityMeshNode {
     _containsObstacle?: boolean;
     _containsTarget?: boolean;
     _targetConnectionName?: string;
+    _shouldBeInGraph?: boolean;
     _parent?: CapacityMeshNode;
 }
 interface CapacityMeshEdge {
@@ -110,6 +112,7 @@ declare class CapacityMeshEdgeSolver extends BaseSolver {
     getNextCapacityMeshEdgeId(): string;
     step(): void;
     private areNodesBordering;
+    private doNodesHaveSharedLayer;
     visualize(): GraphicsObject;
 }
 
@@ -127,7 +130,8 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     opts: CapacityMeshNodeSolverOptions;
     unfinishedNodes: CapacityMeshNode[];
     finishedNodes: CapacityMeshNode[];
-    nodeToOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
+    nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
+    layerCount: number;
     MAX_DEPTH: number;
     targets: Target[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
@@ -135,7 +139,8 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     getNextNodeId(): string;
     getCapacityFromDepth(depth: number): number;
     getTargetIfNodeContainsTarget(node: CapacityMeshNode): Target | null;
-    getOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
+    getXYOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
+    getXYZOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
     /**
      * Checks if the given mesh node overlaps with any obstacle.
      * We treat both obstacles and nodes as axis‐aligned rectangles.
@@ -146,7 +151,7 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
      */
     isNodeCompletelyInsideObstacle(node: CapacityMeshNode): boolean;
     getChildNodes(parent: CapacityMeshNode): CapacityMeshNode[];
-    shouldNodeBeSubdivided(node: CapacityMeshNode): boolean;
+    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
     _step(): void;
     /**
      * Creates a GraphicsObject to visualize the mesh, its nodes, obstacles, and connection points.

package/dist/index.js

@@ -140,7 +140,7 @@ var CapacityMeshEdgeSolver = class extends BaseSolver {
     this.edges = [];
     for (let i = 0; i < this.nodes.length; i++) {
       for (let j = i + 1; j < this.nodes.length; j++) {
-        if (this.areNodesBordering(this.nodes[i], this.nodes[j])) {
+        if (this.areNodesBordering(this.nodes[i], this.nodes[j]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
           this.edges.push({
             capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
             nodeIds: [
@@ -194,16 +194,35 @@ var CapacityMeshEdgeSolver = class extends BaseSolver {
     const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
     return shareVerticalBorder || shareHorizontalBorder;
   }
+  doNodesHaveSharedLayer(node1, node2) {
+    return node1.availableZ.some((z) => node2.availableZ.includes(z));
+  }
   visualize() {
     const graphics = {
       lines: [],
       points: [],
-      rects: this.nodes.map((node) => ({
-        width: Math.max(node.width - 2, node.width * 0.8),
-        height: Math.max(node.height - 2, node.height * 0.8),
-        center: node.center,
-        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : node._containsTarget ? "rgba(0,255,0,0.2)" : "rgba(0,0,0,0.1)"
-      })),
+      rects: this.nodes.map((node) => {
+        const lowestZ = Math.min(...node.availableZ);
+        return {
+          width: Math.max(node.width - 2, node.width * 0.8),
+          height: Math.max(node.height - 2, node.height * 0.8),
+          center: {
+            x: node.center.x + lowestZ * node.width * 0.05,
+            y: node.center.y - lowestZ * node.width * 0.05
+          },
+          fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : {
+            "0,1": "rgba(0,0,0,0.1)",
+            "0": "rgba(0,200,200, 0.1)",
+            "1": "rgba(0,0,200, 0.1)"
+          }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
+          label: [
+            node.capacityMeshNodeId,
+            `availableZ: ${node.availableZ.join(",")}`,
+            `target? ${node._containsTarget ?? false}`,
+            `obs? ${node._containsObstacle ?? false}`
+          ].join("\n")
+        };
+      }),
       circles: []
     };
     for (const edge of this.edges) {
@@ -1074,7 +1093,14 @@ function doRectsOverlap(rect1, rect2) {
   return rect1Left <= rect2Right && rect1Right >= rect2Left && rect1Top <= rect2Bottom && rect1Bottom >= rect2Top;
 }
 
-// lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver.ts
+// lib/utils/mapLayerNameToZ.ts
+var mapLayerNameToZ = (layerName, layerCount) => {
+  if (layerName === "top") return 0;
+  if (layerName === "bottom") return layerCount - 1;
+  return parseInt(layerName.slice(5));
+};
+
+// lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver1.ts
 var CapacityMeshNodeSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
     super();
@@ -1082,6 +1108,16 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     this.opts = opts;
     this.MAX_DEPTH = opts?.capacityDepth ?? this.MAX_DEPTH;
     this.MAX_ITERATIONS = 1e5;
+    this.layerCount = srj.layerCount ?? 2;
+    for (const obstacle of srj.obstacles) {
+      if (!obstacle.zLayers) {
+        const zLayers = [];
+        for (const layer of obstacle.layers) {
+          zLayers.push(mapLayerNameToZ(layer, srj.layerCount));
+        }
+        obstacle.zLayers = zLayers;
+      }
+    }
     const boundsCenter = {
       x: (srj.bounds.minX + srj.bounds.maxX) / 2,
       y: (srj.bounds.minY + srj.bounds.maxY) / 2
@@ -1106,7 +1142,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
       }
     ];
     this.finishedNodes = [];
-    this.nodeToOverlappingObstaclesMap = /* @__PURE__ */ new Map();
+    this.nodeToXYOverlappingObstaclesMap = /* @__PURE__ */ new Map();
     this.targets = this.srj.connections.flatMap(
       (c) => c.pointsToConnect.map((p) => ({
         ...p,
@@ -1117,7 +1153,8 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
   }
   unfinishedNodes;
   finishedNodes;
-  nodeToOverlappingObstaclesMap;
+  nodeToXYOverlappingObstaclesMap;
+  layerCount;
   // targetObstacleMap: Record<string, { obstacle: Obstacle, node: CapacityMeshNode }>
   MAX_DEPTH = 4;
   targets;
@@ -1129,7 +1166,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     return (this.MAX_DEPTH - depth + 1) ** 2;
   }
   getTargetIfNodeContainsTarget(node) {
-    const overlappingObstacles = this.getOverlappingObstacles(node);
+    const overlappingObstacles = this.getXYOverlappingObstacles(node);
     for (const target of this.targets) {
       const targetObstacle = overlappingObstacles.find(
         (o) => isPointInRect(target, o)
@@ -1145,8 +1182,8 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     }
     return null;
   }
-  getOverlappingObstacles(node) {
-    const cachedObstacles = this.nodeToOverlappingObstaclesMap.get(
+  getXYOverlappingObstacles(node) {
+    const cachedObstacles = this.nodeToXYOverlappingObstaclesMap.get(
       node.capacityMeshNodeId
     );
     if (cachedObstacles) {
@@ -1157,7 +1194,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     const nodeRight = node.center.x + node.width / 2;
     const nodeTop = node.center.y - node.height / 2;
     const nodeBottom = node.center.y + node.height / 2;
-    const obstacles = node._parent ? this.getOverlappingObstacles(node._parent) : this.srj.obstacles;
+    const obstacles = node._parent ? this.getXYOverlappingObstacles(node._parent) : this.srj.obstacles;
     for (const obstacle of obstacles) {
       const obsLeft = obstacle.center.x - obstacle.width / 2;
       const obsRight = obstacle.center.x + obstacle.width / 2;
@@ -1165,20 +1202,38 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
       const obsBottom = obstacle.center.y + obstacle.height / 2;
       if (nodeRight >= obsLeft && nodeLeft <= obsRight && nodeBottom >= obsTop && nodeTop <= obsBottom) {
         overlappingObstacles.push(obstacle);
+        continue;
+      }
+      if (nodeLeft >= obsLeft && nodeRight <= obsRight && nodeTop >= obsTop && nodeBottom <= obsBottom) {
+        overlappingObstacles.push(obstacle);
+        continue;
+      }
+      if (obsLeft >= nodeLeft && obsRight <= nodeRight && obsTop >= nodeTop && obsBottom <= nodeBottom) {
+        overlappingObstacles.push(obstacle);
       }
     }
-    this.nodeToOverlappingObstaclesMap.set(
+    this.nodeToXYOverlappingObstaclesMap.set(
       node.capacityMeshNodeId,
       overlappingObstacles
     );
     return overlappingObstacles;
   }
+  getXYZOverlappingObstacles(node) {
+    const xyOverlappingObstacles = this.getXYOverlappingObstacles(node);
+    const xyzOverlappingObstacles = [];
+    for (const obstacle of xyOverlappingObstacles) {
+      if (node.availableZ.some((z) => obstacle.zLayers.includes(z))) {
+        xyzOverlappingObstacles.push(obstacle);
+      }
+    }
+    return xyzOverlappingObstacles;
+  }
   /**
    * Checks if the given mesh node overlaps with any obstacle.
    * We treat both obstacles and nodes as axis‐aligned rectangles.
    */
   doesNodeOverlapObstacle(node) {
-    const overlappingObstacles = this.getOverlappingObstacles(node);
+    const overlappingObstacles = this.getXYZOverlappingObstacles(node);
     if (overlappingObstacles.length > 0) {
       return true;
     }
@@ -1195,7 +1250,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
    * Checks if the entire node is contained within any obstacle.
    */
   isNodeCompletelyInsideObstacle(node) {
-    const overlappingObstacles = this.getOverlappingObstacles(node);
+    const overlappingObstacles = this.getXYZOverlappingObstacles(node);
     const nodeLeft = node.center.x - node.width / 2;
     const nodeRight = node.center.x + node.width / 2;
     const nodeTop = node.center.y - node.height / 2;
@@ -1263,7 +1318,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     }
     return childNodes;
   }
-  shouldNodeBeSubdivided(node) {
+  shouldNodeBeXYSubdivided(node) {
     if (node._depth >= this.MAX_DEPTH) return false;
     if (node._containsTarget) return true;
     if (node._containsObstacle && !node._completelyInsideObstacle) return true;
@@ -1279,7 +1334,7 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     const finishedNewNodes = [];
     const unfinishedNewNodes = [];
     for (const newNode of newNodes) {
-      const shouldBeSubdivided = this.shouldNodeBeSubdivided(newNode);
+      const shouldBeSubdivided = this.shouldNodeBeXYSubdivided(newNode);
       if (shouldBeSubdivided) {
         unfinishedNewNodes.push(newNode);
       } else if (!shouldBeSubdivided && !newNode._containsObstacle) {
@@ -1317,20 +1372,33 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
         height: obstacle.height,
         fill: "rgba(255,0,0,0.3)",
         stroke: "red",
-        label: "obstacle"
+        label: ["obstacle", obstacle.zLayers.join(",")].join("\n")
       });
     }
     const allNodes = [...this.finishedNodes, ...this.unfinishedNodes];
     for (const node of allNodes) {
+      const lowestZ = Math.min(...node.availableZ);
       graphics.rects.push({
-        center: node.center,
+        center: {
+          x: node.center.x + lowestZ * node.width * 0.05,
+          y: node.center.y - lowestZ * node.width * 0.05
+        },
         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(",")}`
+        fill: node._containsObstacle ? "rgba(255,0,0,0.1)" : {
+          "0,1": "rgba(0,0,0,0.1)",
+          "0": "rgba(0,200,200, 0.1)",
+          "1": "rgba(0,0,200, 0.1)"
+        }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
+        label: [
+          node.capacityMeshNodeId,
+          `availableZ: ${node.availableZ.join(",")}`,
+          `target? ${node._containsTarget ?? false}`,
+          `obs? ${node._containsObstacle ?? false}`
+        ].join("\n")
       });
     }
+    graphics.rects.sort((a, b) => a.center.y - b.center.y);
     this.srj.connections.forEach((connection, index) => {
       const color = COLORS[index % COLORS.length];
       for (const pt of connection.pointsToConnect) {
@@ -3717,13 +3785,6 @@ var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
   return result;
 };
 
-// lib/utils/mapLayerNameToZ.ts
-var mapLayerNameToZ = (layerName, layerCount) => {
-  if (layerName === "top") return 0;
-  if (layerName === "bottom") return layerCount - 1;
-  return parseInt(layerName.slice(5));
-};
-
 // lib/solvers/RouteStitchingSolver/SingleHighDensityRouteStitchSolver.ts
 var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
   mergedHdRoute;
@@ -5197,7 +5258,7 @@ Layer: ${segmentPoint.z}`,
   }
 };
 
-// lib/solvers/CapacityMeshSolver/CapacityMeshSolver.ts
+// lib/solvers/AutoroutingPipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
     solverName,