@tscircuit/capacity-autorouter 0.0.29 → 0.0.31

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) {
@@ -1089,24 +918,6 @@ var safeTransparentize = (color, amount) => {
   }
 };
 
-// lib/utils/isPointInRect.ts
-function isPointInRect(point, rect) {
-  return point.x >= rect.center.x - rect.width / 2 && point.x <= rect.center.x + rect.width / 2 && point.y >= rect.center.y - rect.height / 2 && point.y <= rect.center.y + rect.height / 2;
-}
-
-// lib/utils/doRectsOverlap.ts
-function doRectsOverlap(rect1, rect2) {
-  const rect1Left = rect1.center.x - rect1.width / 2;
-  const rect1Right = rect1.center.x + rect1.width / 2;
-  const rect1Top = rect1.center.y - rect1.height / 2;
-  const rect1Bottom = rect1.center.y + rect1.height / 2;
-  const rect2Left = rect2.center.x - rect2.width / 2;
-  const rect2Right = rect2.center.x + rect2.width / 2;
-  const rect2Top = rect2.center.y - rect2.height / 2;
-  const rect2Bottom = rect2.center.y + rect2.height / 2;
-  return rect1Left <= rect2Right && rect1Right >= rect2Left && rect1Top <= rect2Bottom && rect1Bottom >= rect2Top;
-}
-
 // lib/utils/mapLayerNameToZ.ts
 var mapLayerNameToZ = (layerName, layerCount) => {
   if (layerName === "top") return 0;
@@ -1137,6 +948,108 @@ var calculateOptimalCapacityDepth = (initialWidth, targetMinCapacity = 0.5, maxD
   return Math.max(1, depth);
 };
 
+// lib/data-structures/ObstacleTree.ts
+var ObstacleTree = class {
+  constructor(obstacles) {
+    this.obstacles = obstacles;
+    this.buckets = /* @__PURE__ */ new Map();
+    for (let i = 0; i < obstacles.length; i++) {
+      const obstacle = obstacles[i];
+      const nodeMinX = obstacle.center.x - obstacle.width / 2;
+      const nodeMinY = obstacle.center.y - obstacle.height / 2;
+      const nodeMaxX = obstacle.center.x + obstacle.width / 2;
+      const nodeMaxY = obstacle.center.y + obstacle.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, [[obstacle, i]]);
+          } else {
+            bucket.push([obstacle, i]);
+          }
+        }
+      }
+    }
+  }
+  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 obstacles = [];
+    const alreadyAddedObstacles = /* @__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 obstacleWithIndex of bucket) {
+          if (alreadyAddedObstacles.has(obstacleWithIndex[1])) continue;
+          alreadyAddedObstacles.add(obstacleWithIndex[1]);
+          obstacles.push(obstacleWithIndex[0]);
+        }
+      }
+    }
+    return obstacles;
+  }
+};
+
+// lib/data-structures/TargetTree.ts
+var TargetTree = class {
+  constructor(targets) {
+    this.targets = targets;
+    this.buckets = /* @__PURE__ */ new Map();
+    for (let i = 0; i < targets.length; i++) {
+      const target = targets[i];
+      const targetBucketMinX = Math.floor(target.bounds.minX / this.CELL_SIZE) * this.CELL_SIZE;
+      const targetBucketMinY = Math.floor(target.bounds.minY / this.CELL_SIZE) * this.CELL_SIZE;
+      const targetMaxX = target.bounds.maxX;
+      const targetMaxY = target.bounds.maxY;
+      for (let x = targetBucketMinX; x <= targetMaxX; x += this.CELL_SIZE) {
+        for (let y = targetBucketMinY; y <= targetMaxY; y += this.CELL_SIZE) {
+          const bucketKey = this.getBucketKey(x, y);
+          const bucket = this.buckets.get(bucketKey);
+          if (!bucket) {
+            this.buckets.set(bucketKey, [[target, i]]);
+          } else {
+            bucket.push([target, i]);
+          }
+        }
+      }
+    }
+  }
+  buckets;
+  CELL_SIZE = 5;
+  getBucketKey(x, y) {
+    return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
+  }
+  getTargetsInArea(centerX, centerY, width, height) {
+    const targets = [];
+    const alreadyAddedTargets = /* @__PURE__ */ new Set();
+    const minX = Math.floor((centerX - width / 2) / this.CELL_SIZE) * this.CELL_SIZE;
+    const minY = Math.floor((centerY - height / 2) / this.CELL_SIZE) * this.CELL_SIZE;
+    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 targetWithIndex of bucket) {
+          if (alreadyAddedTargets.has(targetWithIndex[1])) continue;
+          alreadyAddedTargets.add(targetWithIndex[1]);
+          targets.push(targetWithIndex[0]);
+        }
+      }
+    }
+    return targets;
+  }
+};
+
 // lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver1.ts
 var CapacityMeshNodeSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
@@ -1180,13 +1093,9 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     ];
     this.finishedNodes = [];
     this.nodeToXYOverlappingObstaclesMap = /* @__PURE__ */ new Map();
-    this.targets = this.srj.connections.flatMap(
-      (c) => c.pointsToConnect.map((p) => ({
-        ...p,
-        connectionName: c.name,
-        availableZ: p.layer === "top" ? [0] : [1]
-      }))
-    );
+    this.obstacleTree = new ObstacleTree(this.srj.obstacles);
+    this.targets = this.computeTargets();
+    this.targetTree = new TargetTree(this.targets);
   }
   unfinishedNodes;
   finishedNodes;
@@ -1195,6 +1104,40 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
   // targetObstacleMap: Record<string, { obstacle: Obstacle, node: CapacityMeshNode }>
   MAX_DEPTH = 4;
   targets;
+  targetTree;
+  obstacleTree;
+  computeTargets() {
+    const targets = [];
+    for (const conn of this.srj.connections) {
+      for (const ptc of conn.pointsToConnect) {
+        const obstacles = this.obstacleTree.getNodesInArea(ptc.x, ptc.y, 0.01, 0.01).filter(
+          (o) => o.zLayers.some((z) => ptc.layer === "top" ? z === 0 : z === 1)
+        );
+        let bounds = {
+          minX: ptc.x - 5e-3,
+          minY: ptc.y - 5e-3,
+          maxX: ptc.x + 5e-3,
+          maxY: ptc.y + 5e-3
+        };
+        if (obstacles.length > 0) {
+          bounds = {
+            minX: Math.min(...obstacles.map((o) => o.center.x - o.width / 2)),
+            minY: Math.min(...obstacles.map((o) => o.center.y - o.height / 2)),
+            maxX: Math.max(...obstacles.map((o) => o.center.x + o.width / 2)),
+            maxY: Math.max(...obstacles.map((o) => o.center.y + o.height / 2))
+          };
+        }
+        const target = {
+          ...ptc,
+          connectionName: conn.name,
+          availableZ: ptc.layer === "top" ? [0] : [1],
+          bounds
+        };
+        targets.push(target);
+      }
+    }
+    return targets;
+  }
   _nextNodeCounter = 0;
   getNextNodeId() {
     return `cn${this._nextNodeCounter++}`;
@@ -1203,18 +1146,17 @@ var CapacityMeshNodeSolver = class extends BaseSolver {
     return (this.MAX_DEPTH - depth + 1) ** 2;
   }
   getTargetIfNodeContainsTarget(node) {
-    const overlappingObstacles = this.getXYOverlappingObstacles(node);
-    for (const target of this.targets) {
-      if (!target.availableZ.some((z) => node.availableZ.includes(z))) continue;
-      const targetObstacle = overlappingObstacles.find(
-        (o) => isPointInRect(target, o)
-      );
-      if (targetObstacle) {
-        if (doRectsOverlap(node, targetObstacle)) {
-          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) {
+    const nearbyTargets = node.width > this.targetTree.CELL_SIZE * 4 ? this.targets : this.targetTree.getTargetsInArea(
+      node.center.x,
+      node.center.y,
+      node.width,
+      node.height
+    );
+    for (const target of nearbyTargets) {
+      if (
+        // Check if the node and target bounds overlap
+        target.bounds.minX <= node.center.x + node.width / 2 && target.bounds.maxX >= node.center.x - node.width / 2 && target.bounds.minY <= node.center.y + node.height / 2 && target.bounds.maxY >= node.center.y - node.height / 2 && target.availableZ.some((z) => node.availableZ.includes(z))
+      ) {
         return target;
       }
     }
@@ -1942,6 +1884,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 +3667,7 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
         z: mapLayerNameToZ(c.pointsToConnect[1].layer, opts.layerCount)
       }
     }));
+    this.MAX_ITERATIONS = 1e5;
   }
   _step() {
     if (this.activeSolver) {
@@ -3921,20 +3904,15 @@ var hasZRangeOverlap = (A_z1, A_z2, B_z1, B_z2) => {
 // lib/solvers/UnravelSolver/getIssuesInSection.ts
 var getIssuesInSection = (section, nodeMap, pointModifications, connMap) => {
   const issues = [];
-  const points = /* @__PURE__ */ new Map();
-  for (const nodeId of section.allNodeIds) {
-    for (const segmentPointId of section.segmentPointsInNode.get(nodeId)) {
-      if (!points.has(segmentPointId)) {
-        const ogPoint = section.segmentPointMap.get(segmentPointId);
-        const modPoint = pointModifications.get(segmentPointId);
-        points.set(segmentPointId, {
-          x: modPoint?.x ?? ogPoint.x,
-          y: modPoint?.y ?? ogPoint.y,
-          z: modPoint?.z ?? ogPoint.z
-        });
-      }
-    }
-  }
+  const points = new Map(section.originalPointMap);
+  for (const [segmentPointId, modPoint] of pointModifications.entries()) {
+    const ogPoint = points.get(segmentPointId);
+    points.set(segmentPointId, {
+      x: modPoint.x ?? ogPoint.x,
+      y: modPoint.y ?? ogPoint.y,
+      z: modPoint.z ?? ogPoint.z
+    });
+  }
   for (const nodeId of section.allNodeIds) {
     const node = nodeMap.get(nodeId);
     if (!node) continue;
@@ -4058,11 +4036,14 @@ var applyOperationToPointModifications = (pointModifications, operation, getPoin
 
 // lib/solvers/UnravelSolver/createSegmentPointMap.ts
 var createSegmentPointMap = (dedupedSegments, segmentIdToNodeIds) => {
+  const segmentPointMap = /* @__PURE__ */ new Map();
+  const nodeToSegmentPointMap = /* @__PURE__ */ new Map();
+  const segmentToSegmentPointMap = /* @__PURE__ */ new Map();
   const segmentPoints = [];
   let highestSegmentPointId = 0;
   for (const segment of dedupedSegments) {
     for (const point of segment.assignedPoints) {
-      segmentPoints.push({
+      const sp = {
         segmentPointId: `SP${highestSegmentPointId++}`,
         segmentId: segment.nodePortSegmentId,
         capacityMeshNodeIds: segmentIdToNodeIds.get(
@@ -4073,14 +4054,26 @@ var createSegmentPointMap = (dedupedSegments, segmentIdToNodeIds) => {
         y: point.point.y,
         z: point.point.z,
         directlyConnectedSegmentPointIds: []
-      });
+      };
+      segmentPointMap.set(sp.segmentPointId, sp);
+      for (const nodeId of sp.capacityMeshNodeIds) {
+        nodeToSegmentPointMap.set(nodeId, [
+          ...nodeToSegmentPointMap.get(nodeId) ?? [],
+          sp.segmentPointId
+        ]);
+      }
+      segmentToSegmentPointMap.set(segment.nodePortSegmentId, [
+        ...segmentToSegmentPointMap.get(segment.nodePortSegmentId) ?? [],
+        sp.segmentPointId
+      ]);
+      segmentPoints.push(sp);
     }
   }
-  const segmentPointMap = /* @__PURE__ */ new Map();
-  for (const segmentPoint of segmentPoints) {
-    segmentPointMap.set(segmentPoint.segmentPointId, segmentPoint);
-  }
-  return segmentPointMap;
+  return {
+    segmentPointMap,
+    nodeToSegmentPointMap,
+    segmentToSegmentPointMap
+  };
 };
 
 // lib/solvers/UnravelSolver/UnravelSectionSolver.ts
@@ -4119,7 +4112,11 @@ var UnravelSectionSolver = class extends BaseSolver {
     this.segmentIdToNodeIds = params.segmentIdToNodeIds;
     this.rootNodeId = params.rootNodeId;
     this.colorMap = params.colorMap ?? {};
-    this.unravelSection = this.createUnravelSection(params.segmentPointMap);
+    this.unravelSection = this.createUnravelSection({
+      segmentPointMap: params.segmentPointMap,
+      nodeToSegmentPointMap: params.nodeToSegmentPointMap,
+      segmentToSegmentPointMap: params.segmentToSegmentPointMap
+    });
     this.tunedNodeCapacityMap = /* @__PURE__ */ new Map();
     for (const nodeId of this.unravelSection.allNodeIds) {
       this.tunedNodeCapacityMap.set(
@@ -4130,38 +4127,43 @@ var UnravelSectionSolver = class extends BaseSolver {
     this.originalCandidate = this.createInitialCandidate();
     this.candidates = [this.originalCandidate];
   }
-  createUnravelSection(segmentPointMap) {
+  createUnravelSection(largeSpMaps) {
     const mutableNodeIds = getNodesNearNode({
       nodeId: this.rootNodeId,
       nodeIdToSegmentIds: this.nodeIdToSegmentIds,
       segmentIdToNodeIds: this.segmentIdToNodeIds,
       hops: this.MUTABLE_HOPS
     });
-    const allNodeIds = getNodesNearNode({
+    const allSectionNodeIds = getNodesNearNode({
       nodeId: this.rootNodeId,
       nodeIdToSegmentIds: this.nodeIdToSegmentIds,
       segmentIdToNodeIds: this.segmentIdToNodeIds,
       hops: this.MUTABLE_HOPS + 1
     });
     const immutableNodeIds = Array.from(
-      new Set(allNodeIds).difference(new Set(mutableNodeIds))
+      new Set(allSectionNodeIds).difference(new Set(mutableNodeIds))
     );
-    if (!segmentPointMap) {
-      segmentPointMap = createSegmentPointMap(
+    if (!largeSpMaps?.segmentPointMap) {
+      largeSpMaps = createSegmentPointMap(
         this.dedupedSegments,
         this.segmentIdToNodeIds
       );
     }
-    const segmentPoints = Array.from(segmentPointMap.values());
     const segmentPointsInNode = /* @__PURE__ */ new Map();
-    for (const segmentPoint of segmentPoints) {
-      for (const nodeId of segmentPoint.capacityMeshNodeIds) {
-        segmentPointsInNode.set(nodeId, [
-          ...segmentPointsInNode.get(nodeId) ?? [],
-          segmentPoint.segmentPointId
-        ]);
+    for (const nodeId of allSectionNodeIds) {
+      segmentPointsInNode.set(
+        nodeId,
+        largeSpMaps.nodeToSegmentPointMap.get(nodeId)
+      );
+    }
+    const sectionPointMap = /* @__PURE__ */ new Map();
+    for (const nodeId of allSectionNodeIds) {
+      for (const segmentPointId of segmentPointsInNode.get(nodeId)) {
+        const point = largeSpMaps.segmentPointMap.get(segmentPointId);
+        sectionPointMap.set(segmentPointId, point);
       }
     }
+    const segmentPoints = Array.from(sectionPointMap.values());
     const segmentPointsInSegment = /* @__PURE__ */ new Map();
     for (const segmentPoint of segmentPoints) {
       segmentPointsInSegment.set(segmentPoint.segmentId, [
@@ -4169,32 +4171,31 @@ 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 = largeSpMaps.segmentPointMap.get(segmentPoints2[i]);
+        for (let j = i + 1; j < segmentPoints2.length; j++) {
+          const B = largeSpMaps.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);
         }
       }
     }
     const segmentPairsInNode = /* @__PURE__ */ new Map();
-    for (const nodeId of allNodeIds) {
+    for (const nodeId of allSectionNodeIds) {
       segmentPairsInNode.set(nodeId, []);
     }
     for (const A of segmentPoints) {
       for (const nodeId of A.capacityMeshNodeIds) {
-        const otherSegmentPoints = segmentPointsInNode.get(nodeId).map((spId) => segmentPointMap.get(spId));
         const segmentPairs = segmentPairsInNode.get(nodeId);
         if (!segmentPairs) continue;
         for (const BId of A.directlyConnectedSegmentPointIds) {
-          const B = segmentPointMap.get(BId);
+          const B = largeSpMaps.segmentPointMap.get(BId);
           if (B.segmentPointId === A.segmentPointId) continue;
           if (!B.capacityMeshNodeIds.some((nId) => nId === nodeId)) continue;
           if (!segmentPairs.some(
@@ -4217,14 +4218,15 @@ var UnravelSectionSolver = class extends BaseSolver {
       }
     }
     return {
-      allNodeIds,
+      allNodeIds: allSectionNodeIds,
       mutableNodeIds,
       immutableNodeIds,
       mutableSegmentIds,
       segmentPairsInNode,
-      segmentPointMap,
+      segmentPointMap: sectionPointMap,
       segmentPointsInNode,
-      segmentPointsInSegment
+      segmentPointsInSegment,
+      originalPointMap: sectionPointMap
     };
   }
   createInitialCandidate() {
@@ -4407,13 +4409,17 @@ var UnravelSectionSolver = class extends BaseSolver {
     }
     return cost;
   }
-  getNeighborByApplyingOperation(currentCandidate, operation) {
+  getUnexploredNeighborByApplyingOperation(currentCandidate, operation) {
     const pointModifications = new Map(currentCandidate.pointModifications);
     applyOperationToPointModifications(
       pointModifications,
       operation,
       (segmentPointId) => this.getPointInCandidate(currentCandidate, segmentPointId)
     );
+    const candidateHash = createPointModificationsHash(pointModifications);
+    if (this.queuedOrExploredCandidatePointModificationHashes.has(candidateHash)) {
+      return null;
+    }
     const issues = getIssuesInSection(
       this.unravelSection,
       this.nodeMap,
@@ -4432,7 +4438,7 @@ var UnravelSectionSolver = class extends BaseSolver {
       h: 0,
       f: g,
       pointModifications,
-      candidateHash: createPointModificationsHash(pointModifications),
+      candidateHash,
       // TODO PERFORMANCE allow disabling this
       // candidateFullHash: createFullPointModificationsHash(
       //   this.unravelSection.segmentPointMap,
@@ -4450,8 +4456,15 @@ var UnravelSectionSolver = class extends BaseSolver {
     const neighbors = [];
     const operations = this.getNeighborOperationsForCandidate(candidate);
     for (const operation of operations) {
-      const neighbor = this.getNeighborByApplyingOperation(candidate, operation);
+      const neighbor = this.getUnexploredNeighborByApplyingOperation(
+        candidate,
+        operation
+      );
+      if (!neighbor) continue;
       neighbors.push(neighbor);
+      this.queuedOrExploredCandidatePointModificationHashes.add(
+        neighbor.candidateHash
+      );
     }
     return neighbors;
   }
@@ -4745,6 +4758,8 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
   dedupedSegments;
   nodeIdToSegmentIds;
   segmentIdToNodeIds;
+  nodeToSegmentPointMap;
+  segmentToSegmentPointMap;
   colorMap;
   tunedNodeCapacityMap;
   MAX_NODE_ATTEMPTS = 2;
@@ -4791,10 +4806,10 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
     for (const [nodeId, node] of this.nodeMap) {
       this.tunedNodeCapacityMap.set(nodeId, getTunedTotalCapacity1(node));
     }
-    this.segmentPointMap = createSegmentPointMap(
-      this.dedupedSegments,
-      this.segmentIdToNodeIds
-    );
+    const { segmentPointMap, nodeToSegmentPointMap, segmentToSegmentPointMap } = createSegmentPointMap(this.dedupedSegments, this.segmentIdToNodeIds);
+    this.segmentPointMap = segmentPointMap;
+    this.nodeToSegmentPointMap = nodeToSegmentPointMap;
+    this.segmentToSegmentPointMap = segmentToSegmentPointMap;
     this.nodePfMap = this.computeInitialPfMap();
   }
   computeInitialPfMap() {
@@ -4810,9 +4825,7 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
       numEntryExitLayerChanges,
       numTransitionCrossings
     } = getIntraNodeCrossingsFromSegments(
-      this.dedupedSegments.filter(
-        (seg) => this.segmentIdToNodeIds.get(seg.nodePortSegmentId).includes(node.capacityMeshNodeId)
-      )
+      this.nodeIdToSegmentIds.get(node.capacityMeshNodeId)?.map((segId) => this.dedupedSegmentMap.get(segId)) || []
     );
     const probabilityOfFailure = calculateNodeProbabilityOfFailure(
       node,
@@ -4854,7 +4867,9 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
         colorMap: this.colorMap,
         rootNodeId: highestPfNodeId,
         MUTABLE_HOPS: this.MUTABLE_HOPS,
-        segmentPointMap: this.segmentPointMap
+        segmentPointMap: this.segmentPointMap,
+        nodeToSegmentPointMap: this.nodeToSegmentPointMap,
+        segmentToSegmentPointMap: this.segmentToSegmentPointMap
       });
     }
     this.activeSolver.step();
@@ -5423,6 +5438,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 +5631,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 +5705,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
   absorbedNodeIds;
   nextBatchNodeIds;
   batchHadModifications;
+  hasComputedAdjacentNodeIds = false;
   newNodes;
   constructor(nodes) {
     super();
@@ -5633,41 +5716,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 +5832,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 +5861,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 +5881,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 +5901,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 +5921,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 +6011,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 +6196,173 @@ 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);
+      const bucketMinX = Math.floor(bounds.minX / this.CELL_SIZE) * this.CELL_SIZE;
+      const bucketMinY = Math.floor(bounds.minY / this.CELL_SIZE) * this.CELL_SIZE;
+      for (let x = bucketMinX; x <= bounds.maxX; x += this.CELL_SIZE) {
+        for (let y = bucketMinY; 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);
+    const minY = Math.min(A.y, B.y);
+    const maxX = Math.max(A.x, B.x);
+    const maxY = Math.max(A.y, B.y);
+    const bucketMinX = Math.floor(minX / this.CELL_SIZE) * this.CELL_SIZE;
+    const bucketMinY = Math.floor(minY / this.CELL_SIZE) * this.CELL_SIZE;
+    for (let x = bucketMinX; x <= maxX; x += this.CELL_SIZE) {
+      for (let y = bucketMinY; 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 +6400,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 +6451,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 +6515,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 +6564,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 +6583,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 +6612,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 +6630,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 +6649,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 +6843,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 +7107,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,