@tscircuit/capacity-autorouter 0.0.30 → 0.0.32

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tscircuit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -118,12 +118,50 @@ declare class CapacityMeshEdgeSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+type BucketCoordinate$1 = `${number}x${number}`;
+declare class ObstacleTree {
+    obstacles: Obstacle[];
+    buckets: Map<BucketCoordinate$1, [Obstacle, number][]>;
+    CELL_SIZE: number;
+    constructor(obstacles: Obstacle[]);
+    getBucketKey(x: number, y: number): BucketCoordinate$1;
+    getNodesInArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
+}
+
+interface Target$1 {
+    x: number;
+    y: number;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    connectionName: string;
+    availableZ: number[];
+}
+type BucketCoordinate = `${number}x${number}`;
+declare class TargetTree {
+    targets: Target$1[];
+    buckets: Map<BucketCoordinate, [Target$1, number][]>;
+    CELL_SIZE: number;
+    constructor(targets: Target$1[]);
+    getBucketKey(x: number, y: number): BucketCoordinate;
+    getTargetsInArea(centerX: number, centerY: number, width: number, height: number): Target$1[];
+}
+
 interface CapacityMeshNodeSolverOptions$1 {
     capacityDepth?: number;
 }
 interface Target {
     x: number;
     y: number;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
     connectionName: string;
     availableZ: number[];
 }
@@ -136,7 +174,10 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     layerCount: number;
     MAX_DEPTH: number;
     targets: Target[];
+    targetTree: TargetTree;
+    obstacleTree: ObstacleTree;
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$1);
+    computeTargets(): Target[];
     _nextNodeCounter: number;
     getNextNodeId(): string;
     getCapacityFromDepth(depth: number): number;
@@ -965,6 +1006,11 @@ interface UnravelSection {
     segmentPairsInNode: Map<CapacityMeshNodeId, Array<[SegmentPointId, SegmentPointId]>>;
     segmentPointsInNode: Map<CapacityMeshNodeId, SegmentPointId[]>;
     segmentPointsInSegment: Map<SegmentId, SegmentPointId[]>;
+    originalPointMap: Map<SegmentPointId, {
+        x: number;
+        y: number;
+        z: number;
+    }>;
 }
 interface UnravelChangeLayerOperation {
     type: "change_layer";
@@ -1013,6 +1059,12 @@ type UnravelCandidate = {
     f: number;
 };
 
+type SegmentPointMapAndReverseMaps = {
+    segmentPointMap: SegmentPointMap;
+    nodeToSegmentPointMap: Map<CapacityMeshNodeId, SegmentPointId[]>;
+    segmentToSegmentPointMap: Map<SegmentId, SegmentPointId[]>;
+};
+
 /**
  * The UntangleSectionSolver optimizes a section of connected capacity nodes
  * with their deduplicated segments.
@@ -1068,8 +1120,10 @@ declare class UnravelSectionSolver extends BaseSolver {
         nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
         segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
         segmentPointMap?: SegmentPointMap;
+        nodeToSegmentPointMap?: Map<CapacityMeshNodeId, SegmentPointId[]>;
+        segmentToSegmentPointMap?: Map<SegmentId, SegmentPointId[]>;
     });
-    createUnravelSection(segmentPointMap?: SegmentPointMap): UnravelSection;
+    createUnravelSection(largeSpMaps?: SegmentPointMapAndReverseMaps): UnravelSection;
     createInitialCandidate(): UnravelCandidate;
     get nextCandidate(): UnravelCandidate | null;
     getPointInCandidate(candidate: UnravelCandidate, segmentPointId: SegmentPointId): {
@@ -1085,7 +1139,7 @@ declare class UnravelSectionSolver extends BaseSolver {
         operationsPerformed: number;
         operation: UnravelOperation;
     }): number;
-    getNeighborByApplyingOperation(currentCandidate: UnravelCandidate, operation: UnravelOperation): UnravelCandidate;
+    getUnexploredNeighborByApplyingOperation(currentCandidate: UnravelCandidate, operation: UnravelOperation): UnravelCandidate | null;
     getNeighborOperationsForCandidate(candidate: UnravelCandidate): UnravelOperation[];
     getNeighbors(candidate: UnravelCandidate): UnravelCandidate[];
     _step(): void;
@@ -1098,6 +1152,8 @@ declare class UnravelMultiSectionSolver extends BaseSolver {
     dedupedSegments: SegmentWithAssignedPoints[];
     nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
     segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+    nodeToSegmentPointMap: Map<CapacityMeshNodeId, SegmentPointId[]>;
+    segmentToSegmentPointMap: Map<SegmentId, SegmentPointId[]>;
     colorMap: Record<string, string>;
     tunedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
     MAX_NODE_ATTEMPTS: number;

package/dist/index.js

@@ -918,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;
@@ -966,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 = {}) {
@@ -1009,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;
@@ -1024,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++}`;
@@ -1032,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;
       }
     }
@@ -3791,19 +3904,14 @@ 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);
@@ -3928,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(
@@ -3943,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
@@ -3989,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(
@@ -4000,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, [
@@ -4041,9 +4173,9 @@ var UnravelSectionSolver = class extends BaseSolver {
     }
     for (const [nodeId, segmentPoints2] of segmentPointsInNode.entries()) {
       for (let i = 0; i < segmentPoints2.length; i++) {
-        const A = segmentPointMap.get(segmentPoints2[i]);
+        const A = largeSpMaps.segmentPointMap.get(segmentPoints2[i]);
         for (let j = i + 1; j < segmentPoints2.length; j++) {
-          const B = segmentPointMap.get(segmentPoints2[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;
@@ -4055,16 +4187,15 @@ var UnravelSectionSolver = class extends BaseSolver {
       }
     }
     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(
@@ -4087,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() {
@@ -4277,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,
@@ -4302,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,
@@ -4320,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;
   }
@@ -4615,6 +4758,8 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
   dedupedSegments;
   nodeIdToSegmentIds;
   segmentIdToNodeIds;
+  nodeToSegmentPointMap;
+  segmentToSegmentPointMap;
   colorMap;
   tunedNodeCapacityMap;
   MAX_NODE_ATTEMPTS = 2;
@@ -4661,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() {
@@ -4680,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,
@@ -4724,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();
@@ -6066,8 +6211,10 @@ var SegmentTree = class {
     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 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) {
@@ -6092,12 +6239,14 @@ var SegmentTree = class {
   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 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) {