@tscircuit/capacity-autorouter 0.0.29 → 0.0.30

package/dist/index.js

@@ -85,177 +85,6 @@ var BaseSolver = class {
   }
 };
 
-// node_modules/@tscircuit/math-utils/dist/chunk-CHQOCSFB.js
-function doSegmentsIntersect(p1, q1, p2, q2) {
-  const o1 = orientation(p1, q1, p2);
-  const o2 = orientation(p1, q1, q2);
-  const o3 = orientation(p2, q2, p1);
-  const o4 = orientation(p2, q2, q1);
-  if (o1 !== o2 && o3 !== o4) {
-    return true;
-  }
-  if (o1 === 0 && onSegment(p1, p2, q1)) return true;
-  if (o2 === 0 && onSegment(p1, q2, q1)) return true;
-  if (o3 === 0 && onSegment(p2, p1, q2)) return true;
-  if (o4 === 0 && onSegment(p2, q1, q2)) return true;
-  return false;
-}
-function orientation(p, q, r) {
-  const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-  if (val === 0) return 0;
-  return val > 0 ? 1 : 2;
-}
-function onSegment(p, q, r) {
-  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
-}
-function pointToSegmentDistance(p, v, w) {
-  const l2 = (w.x - v.x) ** 2 + (w.y - v.y) ** 2;
-  if (l2 === 0) return distance(p, v);
-  let t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
-  t = Math.max(0, Math.min(1, t));
-  const projection = {
-    x: v.x + t * (w.x - v.x),
-    y: v.y + t * (w.y - v.y)
-  };
-  return distance(p, projection);
-}
-function distance(p1, p2) {
-  const dx = p1.x - p2.x;
-  const dy = p1.y - p2.y;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-
-// lib/utils/areNodesBordering.ts
-function areNodesBordering(node1, node2) {
-  const n1Left = node1.center.x - node1.width / 2;
-  const n1Right = node1.center.x + node1.width / 2;
-  const n1Top = node1.center.y - node1.height / 2;
-  const n1Bottom = node1.center.y + node1.height / 2;
-  const n2Left = node2.center.x - node2.width / 2;
-  const n2Right = node2.center.x + node2.width / 2;
-  const n2Top = node2.center.y - node2.height / 2;
-  const n2Bottom = node2.center.y + node2.height / 2;
-  const epsilon = 1e-3;
-  const shareVerticalBorder = (Math.abs(n1Right - n2Left) < epsilon || Math.abs(n1Left - n2Right) < epsilon) && Math.min(n1Bottom, n2Bottom) - Math.max(n1Top, n2Top) >= epsilon;
-  const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
-  return shareVerticalBorder || shareHorizontalBorder;
-}
-
-// lib/solvers/CapacityMeshSolver/CapacityMeshEdgeSolver.ts
-var CapacityMeshEdgeSolver = class extends BaseSolver {
-  constructor(nodes) {
-    super();
-    this.nodes = nodes;
-    this.edges = [];
-  }
-  edges;
-  getNextCapacityMeshEdgeId() {
-    return `ce${this.edges.length}`;
-  }
-  step() {
-    this.edges = [];
-    for (let i = 0; i < this.nodes.length; i++) {
-      for (let j = i + 1; j < this.nodes.length; j++) {
-        const strawNodesWithSameParent = this.nodes[i]._strawNode && this.nodes[j]._strawNode && this.nodes[i]._strawParentCapacityMeshNodeId === this.nodes[j]._strawParentCapacityMeshNodeId;
-        if (!strawNodesWithSameParent && areNodesBordering(this.nodes[i], this.nodes[j]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
-          this.edges.push({
-            capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
-            nodeIds: [
-              this.nodes[i].capacityMeshNodeId,
-              this.nodes[j].capacityMeshNodeId
-            ]
-          });
-        }
-      }
-    }
-    const targetNodes = this.nodes.filter((node) => node._containsTarget);
-    for (const targetNode of targetNodes) {
-      const hasEdge = this.edges.some(
-        (edge) => edge.nodeIds.includes(targetNode.capacityMeshNodeId)
-      );
-      if (hasEdge) continue;
-      let nearestNode = null;
-      let nearestDistance = Infinity;
-      for (const node of this.nodes) {
-        if (node._containsObstacle) continue;
-        if (node._containsTarget) continue;
-        const dist = distance(targetNode.center, node.center);
-        if (dist < nearestDistance) {
-          nearestDistance = dist;
-          nearestNode = node;
-        }
-      }
-      if (nearestNode) {
-        this.edges.push({
-          capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
-          nodeIds: [
-            targetNode.capacityMeshNodeId,
-            nearestNode.capacityMeshNodeId
-          ]
-        });
-      }
-    }
-    this.solved = true;
-  }
-  doNodesHaveSharedLayer(node1, node2) {
-    return node1.availableZ.some((z) => node2.availableZ.includes(z));
-  }
-  visualize() {
-    const graphics = {
-      lines: [],
-      points: [],
-      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) {
-      const node1 = this.nodes.find(
-        (node) => node.capacityMeshNodeId === edge.nodeIds[0]
-      );
-      const node2 = this.nodes.find(
-        (node) => node.capacityMeshNodeId === edge.nodeIds[1]
-      );
-      if (node1?.center && node2?.center) {
-        const lowestZ1 = Math.min(...node1.availableZ);
-        const lowestZ2 = Math.min(...node2.availableZ);
-        const nodeCenter1Adj = {
-          x: node1.center.x + lowestZ1 * node1.width * 0.05,
-          y: node1.center.y - lowestZ1 * node1.width * 0.05
-        };
-        const nodeCenter2Adj = {
-          x: node2.center.x + lowestZ2 * node2.width * 0.05,
-          y: node2.center.y - lowestZ2 * node2.width * 0.05
-        };
-        graphics.lines.push({
-          points: [nodeCenter1Adj, nodeCenter2Adj],
-          strokeDash: node1.availableZ.join(",") === node2.availableZ.join(",") ? void 0 : "10 5"
-        });
-      }
-    }
-    return graphics;
-  }
-};
-
 // node_modules/@babel/runtime/helpers/esm/extends.js
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function(n) {
@@ -1942,6 +1771,46 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
   }
 };
 
+// node_modules/@tscircuit/math-utils/dist/chunk-CHQOCSFB.js
+function doSegmentsIntersect(p1, q1, p2, q2) {
+  const o1 = orientation(p1, q1, p2);
+  const o2 = orientation(p1, q1, q2);
+  const o3 = orientation(p2, q2, p1);
+  const o4 = orientation(p2, q2, q1);
+  if (o1 !== o2 && o3 !== o4) {
+    return true;
+  }
+  if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+  if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+  if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+  if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+  return false;
+}
+function orientation(p, q, r) {
+  const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  if (val === 0) return 0;
+  return val > 0 ? 1 : 2;
+}
+function onSegment(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function pointToSegmentDistance(p, v, w) {
+  const l2 = (w.x - v.x) ** 2 + (w.y - v.y) ** 2;
+  if (l2 === 0) return distance(p, v);
+  let t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
+  t = Math.max(0, Math.min(1, t));
+  const projection = {
+    x: v.x + t * (w.x - v.x),
+    y: v.y + t * (w.y - v.y)
+  };
+  return distance(p, projection);
+}
+function distance(p1, p2) {
+  const dx = p1.x - p2.x;
+  const dy = p1.y - p2.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
 // lib/solvers/HighDensitySolver/SingleHighDensityRouteSolver.ts
 var SingleHighDensityRouteSolver = class extends BaseSolver {
   obstacleRoutes;
@@ -3685,6 +3554,7 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
         z: mapLayerNameToZ(c.pointsToConnect[1].layer, opts.layerCount)
       }
     }));
+    this.MAX_ITERATIONS = 1e5;
   }
   _step() {
     if (this.activeSolver) {
@@ -4169,16 +4039,16 @@ var UnravelSectionSolver = class extends BaseSolver {
         segmentPoint.segmentPointId
       ]);
     }
-    for (let i = 0; i < segmentPoints.length; i++) {
-      const A = segmentPoints[i];
-      for (let j = i + 1; j < segmentPoints.length; j++) {
-        const B = segmentPoints[j];
-        if (B.segmentPointId === A.segmentPointId) continue;
-        if (B.segmentId === A.segmentId) continue;
-        if (B.connectionName !== A.connectionName) continue;
-        if (A.capacityMeshNodeIds.some(
-          (nId) => B.capacityMeshNodeIds.includes(nId)
-        )) {
+    for (const [nodeId, segmentPoints2] of segmentPointsInNode.entries()) {
+      for (let i = 0; i < segmentPoints2.length; i++) {
+        const A = segmentPointMap.get(segmentPoints2[i]);
+        for (let j = i + 1; j < segmentPoints2.length; j++) {
+          const B = segmentPointMap.get(segmentPoints2[j]);
+          if (B.segmentPointId === A.segmentPointId) continue;
+          if (B.segmentId === A.segmentId) continue;
+          if (B.connectionName !== A.connectionName) continue;
+          if (B.directlyConnectedSegmentPointIds.includes(A.segmentPointId))
+            continue;
           A.directlyConnectedSegmentPointIds.push(B.segmentPointId);
           B.directlyConnectedSegmentPointIds.push(A.segmentPointId);
         }
@@ -5423,6 +5293,7 @@ var StrawSolver = class extends BaseSolver {
   nodeIdCounter;
   constructor(params) {
     super();
+    this.MAX_ITERATIONS = 1e5;
     this.strawSize = params.strawSize ?? 0.5;
     this.multiLayerNodes = [];
     this.strawNodes = [];
@@ -5615,6 +5486,72 @@ ${node.width}x${node.height}`
   }
 };
 
+// lib/utils/areNodesBordering.ts
+function areNodesBordering(node1, node2) {
+  const n1Left = node1.center.x - node1.width / 2;
+  const n1Right = node1.center.x + node1.width / 2;
+  const n1Top = node1.center.y - node1.height / 2;
+  const n1Bottom = node1.center.y + node1.height / 2;
+  const n2Left = node2.center.x - node2.width / 2;
+  const n2Right = node2.center.x + node2.width / 2;
+  const n2Top = node2.center.y - node2.height / 2;
+  const n2Bottom = node2.center.y + node2.height / 2;
+  const epsilon = 1e-3;
+  const shareVerticalBorder = (Math.abs(n1Right - n2Left) < epsilon || Math.abs(n1Left - n2Right) < epsilon) && Math.min(n1Bottom, n2Bottom) - Math.max(n1Top, n2Top) >= epsilon;
+  const shareHorizontalBorder = (Math.abs(n1Bottom - n2Top) < epsilon || Math.abs(n1Top - n2Bottom) < epsilon) && Math.min(n1Right, n2Right) - Math.max(n1Left, n2Left) >= epsilon;
+  return shareVerticalBorder || shareHorizontalBorder;
+}
+
+// lib/data-structures/CapacityNodeTree.ts
+var CapacityNodeTree = class {
+  constructor(nodes) {
+    this.nodes = nodes;
+    this.buckets = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const nodeMinX = node.center.x - node.width / 2;
+      const nodeMinY = node.center.y - node.height / 2;
+      const nodeMaxX = node.center.x + node.width / 2;
+      const nodeMaxY = node.center.y + node.height / 2;
+      for (let x = nodeMinX; x <= nodeMaxX; x += this.CELL_SIZE) {
+        for (let y = nodeMinY; y <= nodeMaxY; y += this.CELL_SIZE) {
+          const bucketKey = this.getBucketKey(x, y);
+          const bucket = this.buckets.get(bucketKey);
+          if (!bucket) {
+            this.buckets.set(bucketKey, [node]);
+          } else {
+            bucket.push(node);
+          }
+        }
+      }
+    }
+  }
+  buckets;
+  CELL_SIZE = 0.4;
+  getBucketKey(x, y) {
+    return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
+  }
+  getNodesInArea(centerX, centerY, width, height) {
+    const nodes = [];
+    const alreadyAddedNodes = /* @__PURE__ */ new Set();
+    const minX = centerX - width / 2;
+    const minY = centerY - height / 2;
+    const maxX = centerX + width / 2;
+    const maxY = centerY + height / 2;
+    for (let x = minX; x <= maxX; x += this.CELL_SIZE) {
+      for (let y = minY; y <= maxY; y += this.CELL_SIZE) {
+        const bucketKey = this.getBucketKey(x, y);
+        const bucket = this.buckets.get(bucketKey) || [];
+        for (const node of bucket) {
+          if (alreadyAddedNodes.has(node.capacityMeshNodeId)) continue;
+          alreadyAddedNodes.add(node.capacityMeshNodeId);
+          nodes.push(node);
+        }
+      }
+    }
+    return nodes;
+  }
+};
+
 // lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts
 var EPSILON = 5e-3;
 var SingleLayerNodeMergerSolver = class extends BaseSolver {
@@ -5623,6 +5560,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
   absorbedNodeIds;
   nextBatchNodeIds;
   batchHadModifications;
+  hasComputedAdjacentNodeIds = false;
   newNodes;
   constructor(nodes) {
     super();
@@ -5633,41 +5571,94 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
     }
     this.newNodes = [];
     this.absorbedNodeIds = /* @__PURE__ */ new Set();
-    const nodeWithArea = [];
+    const unprocessedNodesWithArea = [];
     for (const node of nodes) {
       if (node.availableZ.length > 1) {
         this.newNodes.push(node);
         this.absorbedNodeIds.add(node.capacityMeshNodeId);
       } else {
-        nodeWithArea.push([node.capacityMeshNodeId, node.width * node.height]);
+        unprocessedNodesWithArea.push([node, node.width * node.height]);
       }
     }
-    nodeWithArea.sort((a, b) => a[1] - b[1]);
-    for (const [nodeId, area] of nodeWithArea) {
-      const node = this.nodeMap.get(nodeId);
-      this.nodeMap.set(nodeId, {
+    unprocessedNodesWithArea.sort((a, b) => a[1] - b[1]);
+    for (const [node, area] of unprocessedNodesWithArea) {
+      const unprocessedNode = {
         ...node,
         center: { ...node.center }
-      });
+      };
+      this.nodeMap.set(node.capacityMeshNodeId, unprocessedNode);
     }
-    this.currentBatchNodeIds = nodeWithArea.map((n) => n[0]);
+    this.currentBatchNodeIds = unprocessedNodesWithArea.map(
+      ([node]) => node.capacityMeshNodeId
+    );
     this.nextBatchNodeIds = [];
     this.batchHadModifications = false;
   }
+  computeAdjacentNodeIdsForFirstBatch(nodes) {
+    const nodeTrees = [
+      new CapacityNodeTree(nodes.filter((n) => n.availableZ[0] === 0)),
+      new CapacityNodeTree(nodes.filter((n) => n.availableZ[0] === 1))
+    ];
+    for (const node of nodes) {
+      const adjacentNodes = [];
+      const z = node.availableZ[0];
+      const nodesInArea = nodeTrees[z].getNodesInArea(
+        node.center.x,
+        node.center.y,
+        node.width * 4,
+        node.height * 4
+      );
+      for (const unprocessedNode of nodesInArea) {
+        if (unprocessedNode._containsTarget && unprocessedNode._targetConnectionName !== node._targetConnectionName)
+          continue;
+        if (unprocessedNode.capacityMeshNodeId === node.capacityMeshNodeId)
+          continue;
+        if (!areNodesBordering(node, unprocessedNode)) continue;
+        adjacentNodes.push(unprocessedNode);
+      }
+      node._adjacentNodeIds = adjacentNodes.map((n) => n.capacityMeshNodeId);
+    }
+  }
+  // getAdjacentSameLayerUnprocessedNodes1(rootNode: CapacityMeshNode) {
+  //   const adjacentNodes: CapacityMeshNode[] = []
+  //   for (const unprocessedNodeId of this.currentBatchNodeIds) {
+  //     const unprocessedNode = this.nodeMap.get(unprocessedNodeId)!
+  //     if (!areNodesBordering(rootNode, unprocessedNode)) continue
+  //     if (unprocessedNode.availableZ[0] !== rootNode.availableZ[0]) continue
+  //     if (
+  //       unprocessedNode._containsTarget &&
+  //       unprocessedNode._targetConnectionName !== rootNode._targetConnectionName
+  //     )
+  //       continue
+  //     if (this.absorbedNodeIds.has(unprocessedNodeId)) continue
+  //     adjacentNodes.push(unprocessedNode)
+  //   }
+  //   return adjacentNodes
+  // }
   getAdjacentSameLayerUnprocessedNodes(rootNode) {
+    return this.getAdjacentSameLayerUnprocessedNodes2(rootNode);
+  }
+  getAdjacentSameLayerUnprocessedNodes2(rootNode) {
     const adjacentNodes = [];
-    for (const unprocessedNodeId of this.currentBatchNodeIds) {
-      if (this.absorbedNodeIds.has(unprocessedNodeId)) continue;
-      const unprocessedNode = this.nodeMap.get(unprocessedNodeId);
-      if (unprocessedNode.availableZ[0] !== rootNode.availableZ[0]) continue;
-      if (unprocessedNode._containsTarget && unprocessedNode._targetConnectionName !== rootNode._targetConnectionName)
-        continue;
-      if (!areNodesBordering(rootNode, unprocessedNode)) continue;
+    const unprocessedAdjNodes = Array.from(
+      new Set(
+        (rootNode._adjacentNodeIds ?? []).map((a) => this.nodeMap.get(a))
+      )
+    );
+    unprocessedAdjNodes.sort((a, b) => a.width * a.height - b.width * b.height);
+    for (const unprocessedNode of unprocessedAdjNodes) {
+      if (this.absorbedNodeIds.has(unprocessedNode.capacityMeshNodeId)) continue;
       adjacentNodes.push(unprocessedNode);
     }
     return adjacentNodes;
   }
   _step() {
+    if (!this.hasComputedAdjacentNodeIds) {
+      this.computeAdjacentNodeIdsForFirstBatch(
+        this.currentBatchNodeIds.map((id) => this.nodeMap.get(id))
+      );
+      this.hasComputedAdjacentNodeIds = true;
+    }
     let rootNodeId = this.currentBatchNodeIds.pop();
     while (rootNodeId && this.absorbedNodeIds.has(rootNodeId)) {
       rootNodeId = this.currentBatchNodeIds.pop();
@@ -5696,6 +5687,19 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
       this.nextBatchNodeIds.push(rootNodeId);
       return;
     }
+    const absorbAdjacentNodeIds = (nodesToAbsorb) => {
+      for (const adjNode of nodesToAbsorb) {
+        this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
+      }
+      rootNode._adjacentNodeIds = Array.from(
+        new Set(
+          [
+            ...rootNode._adjacentNodeIds ?? [],
+            ...nodesToAbsorb.flatMap((n) => n._adjacentNodeIds ?? [])
+          ].filter((id) => !this.absorbedNodeIds.has(id))
+        )
+      );
+    };
     const adjacentNodesToLeft = adjacentNodes.filter(
       (adjNode) => adjNode.center.x < rootNode.center.x && Math.abs(adjNode.center.y - rootNode.center.y) < rootNode.height / 2
     );
@@ -5712,9 +5716,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
       if (leftAdjNodesTakeUpEntireHeight && leftAdjNodesAreAllSameSize) {
         rootNode.width += leftAdjNodeWidth;
         rootNode.center.x = rootNode.center.x - leftAdjNodeWidth / 2;
-        for (const adjNode of adjacentNodesToLeft) {
-          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
-        }
+        absorbAdjacentNodeIds(adjacentNodesToLeft);
         rootNodeHasGrown = true;
       }
     }
@@ -5734,9 +5736,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
       if (rightAdjNodesTakeUpEntireHeight && rightAdjNodesAreAllSameSize) {
         rootNode.width += rightAdjNodeWidth;
         rootNode.center.x = rootNode.center.x + rightAdjNodeWidth / 2;
-        for (const adjNode of adjacentNodesToRight) {
-          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
-        }
+        absorbAdjacentNodeIds(adjacentNodesToRight);
         rootNodeHasGrown = true;
       }
     }
@@ -5756,9 +5756,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
       if (topAdjNodesTakeUpEntireWidth && topAdjNodesAreAllSameSize) {
         rootNode.height += topAdjNodeHeight;
         rootNode.center.y = rootNode.center.y + topAdjNodeHeight / 2;
-        for (const adjNode of adjacentNodesToTop) {
-          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
-        }
+        absorbAdjacentNodeIds(adjacentNodesToTop);
         rootNodeHasGrown = true;
       }
     }
@@ -5778,9 +5776,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
       if (bottomAdjNodesTakeUpEntireWidth && bottomAdjNodesAreAllSameSize) {
         rootNode.height += bottomAdjNodeHeight;
         rootNode.center.y = rootNode.center.y - bottomAdjNodeHeight / 2;
-        for (const adjNode of adjacentNodesToBottom) {
-          this.absorbedNodeIds.add(adjNode.capacityMeshNodeId);
-        }
+        absorbAdjacentNodeIds(adjacentNodesToBottom);
         rootNodeHasGrown = true;
       }
     }
@@ -5870,7 +5866,7 @@ var SingleSimplifiedPathSolver = class extends BaseSolver {
     this.obstacles = params.obstacles;
     this.connMap = params.connMap;
     this.colorMap = params.colorMap;
-    this.newRoute = [];
+    this.newRoute = [this.inputRoute.route[0]];
     this.newVias = [];
   }
   get simplifiedRoute() {
@@ -6055,32 +6051,169 @@ function segmentsIntersect(A1, A2, B1, B2) {
   return false;
 }
 
+// lib/data-structures/SegmentTree.ts
+var getSegmentBounds = (segment) => {
+  return {
+    minX: Math.min(segment[0].x, segment[1].x),
+    maxX: Math.max(segment[0].x, segment[1].x),
+    minY: Math.min(segment[0].y, segment[1].y),
+    maxY: Math.max(segment[0].y, segment[1].y)
+  };
+};
+var SegmentTree = class {
+  constructor(segments) {
+    this.segments = segments;
+    this.buckets = /* @__PURE__ */ new Map();
+    for (const segment of segments) {
+      const bounds = getSegmentBounds(segment);
+      for (let x = bounds.minX; x <= bounds.maxX; x += this.CELL_SIZE) {
+        for (let y = bounds.minY; y <= bounds.maxY; y += this.CELL_SIZE) {
+          const bucketKey = this.getBucketKey(x, y);
+          const bucket = this.buckets.get(bucketKey);
+          if (!bucket) {
+            this.buckets.set(bucketKey, [
+              [segment[0], segment[1], this.getSegmentKey(segment)]
+            ]);
+          } else {
+            bucket.push([segment[0], segment[1], this.getSegmentKey(segment)]);
+          }
+        }
+      }
+    }
+  }
+  buckets;
+  CELL_SIZE = 0.4;
+  getBucketKey(x, y) {
+    return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
+  }
+  getSegmentKey(segment) {
+    return `${segment[0].x}-${segment[0].y}-${segment[0].z}-${segment[1].x}-${segment[1].y}-${segment[1].z}`;
+  }
+  getSegmentsThatCouldIntersect(A, B) {
+    const segments = [];
+    const alreadyAddedSegments = /* @__PURE__ */ new Set();
+    const minX = Math.min(A.x, B.x) - this.CELL_SIZE;
+    const minY = Math.min(A.y, B.y) - this.CELL_SIZE;
+    const maxX = Math.max(A.x, B.x) + this.CELL_SIZE;
+    const maxY = Math.max(A.y, B.y) + this.CELL_SIZE;
+    for (let x = minX; x <= maxX; x += this.CELL_SIZE) {
+      for (let y = minY; y <= maxY; y += this.CELL_SIZE) {
+        const bucketKey = this.getBucketKey(x, y);
+        const bucket = this.buckets.get(bucketKey) || [];
+        for (const segment of bucket) {
+          const key = segment[2];
+          if (alreadyAddedSegments.has(key)) continue;
+          alreadyAddedSegments.add(key);
+          segments.push(segment);
+        }
+      }
+    }
+    return segments;
+  }
+};
+
 // lib/solvers/SimplifiedPathSolver/SingleSimplifiedPathSolver5_Deg45.ts
 var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
   pathSegments = [];
   totalPathLength = 0;
   headDistanceAlongPath = 0;
   tailDistanceAlongPath = 0;
-  stepSize = 0.25;
+  minStepSize = 0.25;
   // Default step size, can be adjusted
   lastValidPath = null;
   // Store the current valid path
   lastValidPathHeadDistance = 0;
+  /** Amount the step size is reduced when the step isn't possible */
+  STEP_SIZE_REDUCTION_FACTOR = 0.25;
+  maxStepSize = 4;
+  currentStepSize = this.maxStepSize;
+  lastHeadMoveDistance = 0;
+  cachedValidPathSegments;
   filteredObstacles = [];
+  filteredObstaclePathSegments = [];
+  filteredVias = [];
+  segmentTree;
   OBSTACLE_MARGIN = 0.15;
   TAIL_JUMP_RATIO = 0.8;
   constructor(params) {
     super(params);
+    this.cachedValidPathSegments = /* @__PURE__ */ new Set();
     if (this.inputRoute.route.length <= 1) {
       this.newRoute = [...this.inputRoute.route];
       this.solved = true;
       return;
     }
+    const bounds = this.inputRoute.route.reduce(
+      (acc, point) => {
+        acc.minX = Math.min(acc.minX, point.x);
+        acc.maxX = Math.max(acc.maxX, point.x);
+        acc.minY = Math.min(acc.minY, point.y);
+        acc.maxY = Math.max(acc.maxY, point.y);
+        return acc;
+      },
+      { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity }
+    );
     this.filteredObstacles = this.obstacles.filter(
       (obstacle) => !obstacle.connectedTo.some(
         (id) => this.connMap.areIdsConnected(this.inputRoute.connectionName, id)
       )
+    ).filter((obstacle) => {
+      if (obstacle.connectedTo.some(
+        (obsId) => this.connMap.areIdsConnected(this.inputRoute.connectionName, obsId)
+      )) {
+        return false;
+      }
+      const obstacleMinX = obstacle.center.x - obstacle.width / 2 - this.OBSTACLE_MARGIN;
+      const obstacleMaxX = obstacle.center.x + obstacle.width / 2 + this.OBSTACLE_MARGIN;
+      const obstacleMinY = obstacle.center.y - obstacle.height / 2 - this.OBSTACLE_MARGIN;
+      const obstacleMaxY = obstacle.center.y + obstacle.height / 2 + this.OBSTACLE_MARGIN;
+      return obstacleMinX <= bounds.maxX && obstacleMaxX >= bounds.minX && obstacleMinY <= bounds.maxY && obstacleMaxY >= bounds.minY;
+    });
+    this.filteredObstaclePathSegments = this.otherHdRoutes.flatMap(
+      (hdRoute) => {
+        if (this.connMap.areIdsConnected(
+          this.inputRoute.connectionName,
+          hdRoute.connectionName
+        )) {
+          return [];
+        }
+        const route = hdRoute.route;
+        const segments = [];
+        for (let i = 0; i < route.length - 1; i++) {
+          const start = route[i];
+          const end = route[i + 1];
+          const minX = Math.min(start.x, end.x);
+          const maxX = Math.max(start.x, end.x);
+          const minY = Math.min(start.y, end.y);
+          const maxY = Math.max(start.y, end.y);
+          if (minX <= bounds.maxX && maxX >= bounds.minX && minY <= bounds.maxY && maxY >= bounds.minY) {
+            segments.push([start, end]);
+          }
+        }
+        return segments;
+      }
     );
+    this.segmentTree = new SegmentTree(this.filteredObstaclePathSegments);
+    this.filteredVias = this.otherHdRoutes.flatMap((hdRoute) => {
+      if (this.connMap.areIdsConnected(
+        this.inputRoute.connectionName,
+        hdRoute.connectionName
+      )) {
+        return [];
+      }
+      const vias = hdRoute.vias;
+      const filteredVias = [];
+      for (const via of vias) {
+        const minX = via.x - hdRoute.viaDiameter / 2;
+        const maxX = via.x + hdRoute.viaDiameter / 2;
+        const minY = via.y - hdRoute.viaDiameter / 2;
+        const maxY = via.y + hdRoute.viaDiameter / 2;
+        if (minX <= bounds.maxX && maxX >= bounds.minX && minY <= bounds.maxY && maxY >= bounds.minY) {
+          filteredVias.push({ ...via, diameter: hdRoute.viaDiameter });
+        }
+      }
+      return filteredVias;
+    });
     this.computePathSegments();
   }
   // Compute the path segments and their distances
@@ -6118,7 +6251,7 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     return {
       x: segment.start.x + factor * (segment.end.x - segment.start.x),
       y: segment.start.y + factor * (segment.end.y - segment.start.y),
-      z: segment.start.z
+      z: factor < 0.5 ? segment.start.z : segment.end.z
       // Z doesn't interpolate - use the segment's start z value
     };
   }
@@ -6169,33 +6302,24 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
         return false;
       }
     }
-    for (const route of this.otherHdRoutes) {
-      if (this.connMap.areIdsConnected(
-        this.inputRoute.connectionName,
-        route.connectionName
-      )) {
-        continue;
-      }
-      for (let j = 0; j < route.route.length - 1; j++) {
-        const routeStart = route.route[j];
-        const routeEnd = route.route[j + 1];
-        if (routeStart.z === start.z && routeEnd.z === start.z) {
-          if (minimumDistanceBetweenSegments(
-            { x: start.x, y: start.y },
-            { x: end.x, y: end.y },
-            { x: routeStart.x, y: routeStart.y },
-            { x: routeEnd.x, y: routeEnd.y }
-          ) < this.OBSTACLE_MARGIN) {
-            return false;
-          }
-        }
-      }
-      for (const via of route.vias) {
-        if (pointToSegmentDistance(via, start, end) < this.OBSTACLE_MARGIN + route.viaDiameter / 2) {
+    const segmentsThatCouldIntersect = this.segmentTree.getSegmentsThatCouldIntersect(start, end);
+    for (const [otherSegA, otherSegB] of segmentsThatCouldIntersect) {
+      if (otherSegA.z === start.z && otherSegB.z === start.z) {
+        if (minimumDistanceBetweenSegments(
+          { x: start.x, y: start.y },
+          { x: end.x, y: end.y },
+          { x: otherSegA.x, y: otherSegA.y },
+          { x: otherSegB.x, y: otherSegB.y }
+        ) < this.OBSTACLE_MARGIN) {
           return false;
         }
       }
     }
+    for (const via of this.filteredVias) {
+      if (pointToSegmentDistance(via, start, end) < this.OBSTACLE_MARGIN + via.diameter / 2) {
+        return false;
+      }
+    }
     return true;
   }
   // Check if a path with multiple points is valid
@@ -6242,6 +6366,24 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       }
       this.newRoute.push(path[i]);
     }
+    this.currentStepSize = this.maxStepSize;
+  }
+  moveHead(distance4) {
+    this.lastHeadMoveDistance = distance4;
+    this.headDistanceAlongPath = Math.min(
+      this.headDistanceAlongPath + distance4,
+      this.totalPathLength
+    );
+  }
+  stepBackAndReduceStepSize() {
+    this.headDistanceAlongPath = Math.max(
+      this.tailDistanceAlongPath,
+      this.headDistanceAlongPath - this.lastHeadMoveDistance
+    );
+    this.currentStepSize = Math.max(
+      this.minStepSize,
+      this.currentStepSize * this.STEP_SIZE_REDUCTION_FACTOR
+    );
   }
   _step() {
     const tailHasReachedEnd = this.tailDistanceAlongPath >= this.totalPathLength;
@@ -6273,10 +6415,7 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
         }
       }
     }
-    this.headDistanceAlongPath = Math.min(
-      this.headDistanceAlongPath + this.stepSize,
-      this.totalPathLength
-    );
+    this.moveHead(this.currentStepSize);
     const tailPoint = this.getPointAtDistance(this.tailDistanceAlongPath);
     const headPoint = this.getPointAtDistance(this.headDistanceAlongPath);
     const tailIndex = this.getNearestIndexForDistance(
@@ -6295,21 +6434,26 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
         break;
       }
     }
+    if (layerChangeBtwHeadAndTail && this.lastHeadMoveDistance > this.minStepSize) {
+      this.stepBackAndReduceStepSize();
+      return;
+    }
     if (layerChangeBtwHeadAndTail && layerChangeAtDistance > 0) {
+      const pointBeforeChange = this.getPointAtDistance(layerChangeAtDistance);
       if (this.lastValidPath) {
         this.addPathToResult(this.lastValidPath);
         this.lastValidPath = null;
       }
-      const pointBeforeChange = this.getPointAtDistance(layerChangeAtDistance);
-      const pointAfterChange = this.inputRoute.route[this.getNearestIndexForDistance(layerChangeAtDistance) + 1];
+      const indexAfterLayerChange = this.getNearestIndexForDistance(layerChangeAtDistance) + 1;
+      const pointAfterChange = this.inputRoute.route[indexAfterLayerChange];
       this.newVias.push({
         x: pointAfterChange.x,
         y: pointAfterChange.y
       });
       this.newRoute.push(pointAfterChange);
-      const nextTailIndex = this.getNearestIndexForDistance(layerChangeAtDistance) + 1;
-      if (this.pathSegments[nextTailIndex]) {
-        this.tailDistanceAlongPath = this.pathSegments[nextTailIndex].startDistance;
+      this.currentStepSize = this.maxStepSize;
+      if (this.pathSegments[indexAfterLayerChange]) {
+        this.tailDistanceAlongPath = this.pathSegments[indexAfterLayerChange].startDistance;
         this.headDistanceAlongPath = this.tailDistanceAlongPath;
       } else {
         console.error("Creating via at end, this is probably not right");
@@ -6319,9 +6463,13 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       return;
     }
     const path45 = this.find45DegreePath(tailPoint, headPoint);
+    if (!path45 && this.lastHeadMoveDistance > this.minStepSize) {
+      this.stepBackAndReduceStepSize();
+      return;
+    }
     if (!path45 && !this.lastValidPath) {
-      this.tailDistanceAlongPath += this.stepSize;
-      this.headDistanceAlongPath += this.stepSize;
+      this.tailDistanceAlongPath += this.minStepSize;
+      this.moveHead(this.minStepSize);
       return;
     }
     if (path45) {
@@ -6333,11 +6481,8 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       this.addPathToResult(this.lastValidPath);
       this.lastValidPath = null;
       this.tailDistanceAlongPath = this.lastValidPathHeadDistance;
+      this.moveHead(this.minStepSize);
     }
-    this.headDistanceAlongPath = Math.min(
-      this.headDistanceAlongPath + this.stepSize,
-      this.totalPathLength
-    );
   }
   visualize() {
     const graphics = this.getVisualsForNewRouteAndObstacles();
@@ -6355,6 +6500,15 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       color: "orange",
       label: ["Head", `z: ${headPoint.z}`].join("\n")
     });
+    const tentativeHead = this.getPointAtDistance(
+      this.headDistanceAlongPath + this.currentStepSize
+    );
+    graphics.points.push({
+      x: tentativeHead.x,
+      y: tentativeHead.y,
+      color: "red",
+      label: ["Tentative Head", `z: ${tentativeHead.z}`].join("\n")
+    });
     let distance4 = 0;
     while (distance4 < this.totalPathLength) {
       const point = this.getPointAtDistance(distance4);
@@ -6540,6 +6694,157 @@ var MultiSimplifiedPathSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/CapacityMeshSolver/CapacityMeshEdgeSolver.ts
+var CapacityMeshEdgeSolver = class extends BaseSolver {
+  constructor(nodes) {
+    super();
+    this.nodes = nodes;
+    this.edges = [];
+  }
+  edges;
+  getNextCapacityMeshEdgeId() {
+    return `ce${this.edges.length}`;
+  }
+  step() {
+    this.edges = [];
+    for (let i = 0; i < this.nodes.length; i++) {
+      for (let j = i + 1; j < this.nodes.length; j++) {
+        const strawNodesWithSameParent = this.nodes[i]._strawNode && this.nodes[j]._strawNode && this.nodes[i]._strawParentCapacityMeshNodeId === this.nodes[j]._strawParentCapacityMeshNodeId;
+        if (!strawNodesWithSameParent && areNodesBordering(this.nodes[i], this.nodes[j]) && this.doNodesHaveSharedLayer(this.nodes[i], this.nodes[j])) {
+          this.edges.push({
+            capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
+            nodeIds: [
+              this.nodes[i].capacityMeshNodeId,
+              this.nodes[j].capacityMeshNodeId
+            ]
+          });
+        }
+      }
+    }
+    this.handleTargetNodes();
+    this.solved = true;
+  }
+  handleTargetNodes() {
+    const targetNodes = this.nodes.filter((node) => node._containsTarget);
+    for (const targetNode of targetNodes) {
+      const hasEdge = this.edges.some(
+        (edge) => edge.nodeIds.includes(targetNode.capacityMeshNodeId)
+      );
+      if (hasEdge) continue;
+      let nearestNode = null;
+      let nearestDistance = Infinity;
+      for (const node of this.nodes) {
+        if (node._containsObstacle) continue;
+        if (node._containsTarget) continue;
+        const dist = distance(targetNode.center, node.center);
+        if (dist < nearestDistance) {
+          nearestDistance = dist;
+          nearestNode = node;
+        }
+      }
+      if (nearestNode) {
+        this.edges.push({
+          capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
+          nodeIds: [
+            targetNode.capacityMeshNodeId,
+            nearestNode.capacityMeshNodeId
+          ]
+        });
+      }
+    }
+  }
+  doNodesHaveSharedLayer(node1, node2) {
+    return node1.availableZ.some((z) => node2.availableZ.includes(z));
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      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) {
+      const node1 = this.nodes.find(
+        (node) => node.capacityMeshNodeId === edge.nodeIds[0]
+      );
+      const node2 = this.nodes.find(
+        (node) => node.capacityMeshNodeId === edge.nodeIds[1]
+      );
+      if (node1?.center && node2?.center) {
+        const lowestZ1 = Math.min(...node1.availableZ);
+        const lowestZ2 = Math.min(...node2.availableZ);
+        const nodeCenter1Adj = {
+          x: node1.center.x + lowestZ1 * node1.width * 0.05,
+          y: node1.center.y - lowestZ1 * node1.width * 0.05
+        };
+        const nodeCenter2Adj = {
+          x: node2.center.x + lowestZ2 * node2.width * 0.05,
+          y: node2.center.y - lowestZ2 * node2.width * 0.05
+        };
+        graphics.lines.push({
+          points: [nodeCenter1Adj, nodeCenter2Adj],
+          strokeDash: node1.availableZ.join(",") === node2.availableZ.join(",") ? void 0 : "10 5"
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/CapacityMeshSolver/CapacityMeshEdgeSolver2_NodeTreeOptimization.ts
+var CapacityMeshEdgeSolver2_NodeTreeOptimization = class extends CapacityMeshEdgeSolver {
+  step() {
+    this.edges = [];
+    const edgeSet = /* @__PURE__ */ new Set();
+    const nodeTree = new CapacityNodeTree(this.nodes);
+    for (let i = 0; i < this.nodes.length; i++) {
+      const A = this.nodes[i];
+      const maybeAdjNodes = nodeTree.getNodesInArea(
+        A.center.x,
+        A.center.y,
+        A.width * 2,
+        A.height * 2
+      );
+      for (const B of maybeAdjNodes) {
+        const areBordering = areNodesBordering(A, B);
+        if (!areBordering) continue;
+        const strawNodesWithSameParent = A._strawNode && B._strawNode && A._strawParentCapacityMeshNodeId === B._strawParentCapacityMeshNodeId;
+        if (!strawNodesWithSameParent && this.doNodesHaveSharedLayer(A, B) && !edgeSet.has(`${A.capacityMeshNodeId}-${B.capacityMeshNodeId}`)) {
+          edgeSet.add(`${A.capacityMeshNodeId}-${B.capacityMeshNodeId}`);
+          edgeSet.add(`${B.capacityMeshNodeId}-${A.capacityMeshNodeId}`);
+          this.edges.push({
+            capacityMeshEdgeId: this.getNextCapacityMeshEdgeId(),
+            nodeIds: [A.capacityMeshNodeId, B.capacityMeshNodeId]
+          });
+        }
+      }
+    }
+    this.handleTargetNodes();
+    this.solved = true;
+  }
+};
+
 // lib/solvers/AutoroutingPipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -6653,9 +6958,11 @@ var CapacityMeshSolver = class extends BaseSolver {
         }
       }
     ),
-    definePipelineStep("edgeSolver", CapacityMeshEdgeSolver, (cms) => [
-      cms.capacityNodes
-    ]),
+    definePipelineStep(
+      "edgeSolver",
+      CapacityMeshEdgeSolver2_NodeTreeOptimization,
+      (cms) => [cms.capacityNodes]
+    ),
     definePipelineStep("pathingSolver", CapacityPathingSolver5, (cms) => [
       {
         simpleRouteJson: cms.srjWithPointPairs,