@tscircuit/capacity-autorouter 0.0.43 → 0.0.44

package/dist/index.js

@@ -1642,30 +1642,40 @@ var CapacityEdgeToPortSegmentSolver = class extends BaseSolver {
       const node = this.nodeMap.get(nodeId);
       segments.forEach((segment) => {
         const isVertical = segment.start.x === segment.end.x;
-        const THICKNESS = 0.1 / segment.connectionNames.length;
+        const THICKNESS = 0.05;
         for (let i = 0; i < segment.connectionNames.length; i++) {
-          const offsetAmount = (i / (segment.connectionNames.length - 1 + 1e-6) - 0.5) * THICKNESS;
           const offset = {
-            x: isVertical ? offsetAmount : 0,
-            y: isVertical ? 0 : offsetAmount
+            x: 0.05 * Math.max(...segment.availableZ),
+            y: 0.05 * Math.max(...segment.availableZ)
           };
           const trueSegmentCenter = {
-            x: (segment.start.x + segment.end.x) / 2 + offset.x,
-            y: (segment.start.y + segment.end.y) / 2 + offset.y
+            x: (segment.start.x + segment.end.x) / 2,
+            y: (segment.start.y + segment.end.y) / 2
           };
-          graphics.rects.push({
-            center: {
-              x: (trueSegmentCenter.x * 6 + node.center.x) / 7,
-              y: (trueSegmentCenter.y * 6 + node.center.y) / 7
-            },
-            width: isVertical ? THICKNESS : Math.abs(segment.end.x - segment.start.x),
-            height: isVertical ? Math.abs(segment.end.y - segment.start.y) : THICKNESS,
-            fill: safeTransparentize(
+          const segmentCenter = {
+            x: trueSegmentCenter.x + offset.x,
+            y: trueSegmentCenter.y + offset.y
+          };
+          if (offset.x > 0) {
+            graphics.lines.push({
+              points: [trueSegmentCenter, segmentCenter],
+              strokeColor: "rgba(0, 0, 0, 0.25)",
+              strokeDash: "5 5"
+            });
+          }
+          graphics.points.push({
+            x: segmentCenter.x,
+            y: segmentCenter.y,
+            label: `${nodeId}: ${segment.connectionNames.join(", ")}
+availableZ: ${segment.availableZ.join(",")}
+nodePortSegmentId: ${segment.nodePortSegmentId}`
+          });
+          graphics.lines.push({
+            points: [segment.start, segment.end],
+            strokeColor: safeTransparentize(
               this.colorMap[segment.connectionNames[i]],
               0.6
-            ),
-            label: `${nodeId}: ${segment.connectionNames.join(", ")}
-availableZ: ${segment.availableZ.join(",")}`
+            )
           });
         }
       });
@@ -1710,19 +1720,50 @@ function findOverlappingSegment(node, adjNode) {
     };
   }
 }
+var EPSILON = 1e-9;
+function coordsAreEqual(p1, p2) {
+  return Math.abs(p1.x - p2.x) < EPSILON && Math.abs(p1.y - p2.y) < EPSILON;
+}
+function availableZAreEqual(zA1, zA2) {
+  if (zA1.length !== zA2.length) {
+    return false;
+  }
+  for (let i = 0; i < zA1.length; i++) {
+    if (zA1[i] !== zA2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
 function combineSegments(segments) {
   const mergedSegments = [];
-  const remainingSegments = [...segments];
+  const remainingSegments = segments.map((s) => ({
+    ...s,
+    connectionNames: [...s.connectionNames],
+    availableZ: [...s.availableZ].sort((a, b) => a - b)
+    // Ensure Z is sorted for comparison
+  }));
   while (remainingSegments.length > 0) {
     const segmentUnderTest = remainingSegments.pop();
-    const overlappingMergedSegment = mergedSegments.find((segment) => {
-      return segment.start.x === segmentUnderTest.start.x && segment.start.y === segmentUnderTest.start.y && segment.end.x === segmentUnderTest.end.x && segment.end.y === segmentUnderTest.end.y;
-    });
-    if (overlappingMergedSegment) {
-      overlappingMergedSegment.connectionNames.push(
-        ...segmentUnderTest.connectionNames
+    let foundMatch = false;
+    for (let i = 0; i < mergedSegments.length; i++) {
+      const mergedSegment = mergedSegments[i];
+      const geometryMatch = coordsAreEqual(mergedSegment.start, segmentUnderTest.start) && coordsAreEqual(mergedSegment.end, segmentUnderTest.end) || coordsAreEqual(mergedSegment.start, segmentUnderTest.end) && coordsAreEqual(mergedSegment.end, segmentUnderTest.start);
+      const zMatch = availableZAreEqual(
+        mergedSegment.availableZ,
+        segmentUnderTest.availableZ
       );
-    } else {
+      if (geometryMatch && zMatch) {
+        const currentConnections = new Set(mergedSegment.connectionNames);
+        segmentUnderTest.connectionNames.forEach(
+          (cn) => currentConnections.add(cn)
+        );
+        mergedSegment.connectionNames = Array.from(currentConnections);
+        foundMatch = true;
+        break;
+      }
+    }
+    if (!foundMatch) {
       mergedSegments.push(segmentUnderTest);
     }
   }
@@ -1847,25 +1888,49 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
    */
   visualize() {
     const graphics = {
-      points: this.solvedSegments.flatMap(
-        (seg) => seg.assignedPoints.map((ap) => ({
-          x: ap.point.x,
-          y: ap.point.y,
-          label: [
-            `${seg.capacityMeshNodeId}-${ap.connectionName}`,
-            `z: ${seg.availableZ.join(",")}`
-          ].join("\n"),
-          color: this.colorMap[ap.connectionName],
-          step: 4
-        }))
-      ),
+      points: [],
       lines: this.solvedSegments.map((seg) => ({
         points: [seg.start, seg.end],
         step: 4
       })),
       rects: [],
-      circles: []
+      circles: [],
+      coordinateSystem: "cartesian",
+      title: "Capacity Segment to Point Solver"
     };
+    for (let i = 0; i < this.solvedSegments.length; i++) {
+      const seg = this.solvedSegments[i];
+      for (let j = 0; j < seg.assignedPoints.length; j++) {
+        const ap = seg.assignedPoints[j];
+        const truePoint = {
+          x: ap.point.x,
+          y: ap.point.y
+        };
+        const offsetPoint = {
+          x: ap.point.x + ap.point.z * 0.05,
+          y: ap.point.y + ap.point.z * 0.05
+        };
+        if (ap.point.z !== 0) {
+          graphics.lines.push({
+            points: [truePoint, offsetPoint],
+            strokeColor: "rgba(0, 0, 0, 0.25)",
+            strokeDash: "5 5",
+            step: 4
+          });
+        }
+        graphics.points.push({
+          x: offsetPoint.x,
+          y: offsetPoint.y,
+          label: [
+            `${seg.capacityMeshNodeId}-${ap.connectionName}`,
+            `z: ${seg.availableZ.join(",")}`,
+            `nodePortSegmentId: ${seg.nodePortSegmentId}`
+          ].join("\n"),
+          color: this.colorMap[ap.connectionName],
+          step: 4
+        });
+      }
+    }
     const dashedLines = [];
     const nodeConnections = {};
     for (const seg of this.solvedSegments) {
@@ -2075,6 +2140,12 @@ var SingleRouteCandidatePriorityQueue = class {
     this.heapifyDown();
     return item;
   }
+  peek() {
+    if (this.heap.length === 0) {
+      return null;
+    }
+    return this.heap[0];
+  }
   enqueue(item) {
     this.heap.push(item);
     this.heapifyUp();
@@ -2157,16 +2228,6 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     this.obstacleMargin = opts.obstacleMargin ?? 0.2;
     this.layerCount = opts.layerCount ?? 2;
     this.exploredNodes = /* @__PURE__ */ new Set();
-    this.candidates = new SingleRouteCandidatePriorityQueue([
-      {
-        ...opts.A,
-        z: opts.A.z ?? 0,
-        g: 0,
-        h: 0,
-        f: 0,
-        parent: null
-      }
-    ]);
     this.straightLineDistance = distance(this.A, this.B);
     this.futureConnections = opts.futureConnections ?? [];
     this.MAX_ITERATIONS = 5e3;
@@ -2189,6 +2250,25 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     if (this.futureConnections && this.futureConnections.length === 0 && this.obstacleRoutes.length === 0) {
       this.handleSimpleCases();
     }
+    this.candidates = new SingleRouteCandidatePriorityQueue([
+      {
+        ...opts.A,
+        x: Math.floor(opts.A.x / this.cellStep) * this.cellStep,
+        y: Math.floor(opts.A.y / this.cellStep) * this.cellStep,
+        z: opts.A.z ?? 0,
+        g: 0,
+        h: 0,
+        f: 0,
+        parent: {
+          ...opts.A,
+          z: opts.A.z ?? 0,
+          g: 0,
+          h: 0,
+          f: 0,
+          parent: null
+        }
+      }
+    ]);
   }
   handleSimpleCases() {
     this.solved = true;
@@ -2468,6 +2548,19 @@ z: ${this.B.z}`,
         label: `Explored (z=${z})`
       });
     }
+    if (this.candidates.peek()) {
+      const nextNode = this.candidates.peek();
+      graphics.rects.push({
+        center: {
+          x: nextNode.x + nextNode.z * this.cellStep / 20,
+          y: nextNode.y + nextNode.z * this.cellStep / 20
+        },
+        fill: "rgba(0, 255, 0, 0.8)",
+        width: this.cellStep * 0.9,
+        height: this.cellStep * 0.9,
+        label: `Next (z=${nextNode.z})`
+      });
+    }
     for (const route of this.obstacleRoutes) {
       for (const via of route.vias) {
         graphics.circles.push({
@@ -3922,14 +4015,14 @@ function distance2(p1, p2) {
 }
 
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/calculateSideTraversal.ts
-var EPSILON = 1e-9;
+var EPSILON2 = 1e-9;
 function calculateSegmentTraversal(startPoint, endPoint, bounds) {
   const startAngle = pointToAngle(startPoint, bounds);
   let endAngle = pointToAngle(endPoint, bounds);
   if (endAngle < startAngle) {
     endAngle += 2 * Math.PI;
   }
-  if (Math.abs(endAngle - startAngle) < EPSILON) {
+  if (Math.abs(endAngle - startAngle) < EPSILON2) {
     return { left: 0, top: 0, right: 0, bottom: 0 };
   }
   return calculateSidePercentages(startAngle, endAngle, bounds);
@@ -3944,7 +4037,7 @@ function calculateTraversalPercentages(A, B, C, bounds) {
     bottom: Math.min(1, percentagesAB.bottom + percentagesBC.bottom)
   };
   for (const key in totalPercentages) {
-    if (Math.abs(totalPercentages[key]) < EPSILON) {
+    if (Math.abs(totalPercentages[key]) < EPSILON2) {
       totalPercentages[key] = 0;
     }
   }
@@ -3953,17 +4046,17 @@ function calculateTraversalPercentages(A, B, C, bounds) {
 function pointToAngle(point, bounds) {
   const width = bounds.maxX - bounds.minX;
   const height = bounds.maxY - bounds.minY;
-  if (width < EPSILON && height < EPSILON) return 0;
+  if (width < EPSILON2 && height < EPSILON2) return 0;
   const perimeter = 2 * (width + height);
-  if (perimeter < EPSILON) return 0;
+  if (perimeter < EPSILON2) return 0;
   let distance6 = 0;
-  if (Math.abs(point.y - bounds.maxY) < EPSILON && point.x >= bounds.minX - EPSILON && point.x <= bounds.maxX + EPSILON) {
+  if (Math.abs(point.y - bounds.maxY) < EPSILON2 && point.x >= bounds.minX - EPSILON2 && point.x <= bounds.maxX + EPSILON2) {
     distance6 = Math.max(0, Math.min(width, point.x - bounds.minX));
-  } else if (Math.abs(point.x - bounds.maxX) < EPSILON && point.y >= bounds.minY - EPSILON && point.y <= bounds.maxY + EPSILON) {
+  } else if (Math.abs(point.x - bounds.maxX) < EPSILON2 && point.y >= bounds.minY - EPSILON2 && point.y <= bounds.maxY + EPSILON2) {
     distance6 = width + Math.max(0, Math.min(height, bounds.maxY - point.y));
-  } else if (Math.abs(point.y - bounds.minY) < EPSILON && point.x >= bounds.minX - EPSILON && point.x <= bounds.maxX + EPSILON) {
+  } else if (Math.abs(point.y - bounds.minY) < EPSILON2 && point.x >= bounds.minX - EPSILON2 && point.x <= bounds.maxX + EPSILON2) {
     distance6 = width + height + Math.max(0, Math.min(width, bounds.maxX - point.x));
-  } else if (Math.abs(point.x - bounds.minX) < EPSILON && point.y >= bounds.minY - EPSILON && point.y <= bounds.maxY + EPSILON) {
+  } else if (Math.abs(point.x - bounds.minX) < EPSILON2 && point.y >= bounds.minY - EPSILON2 && point.y <= bounds.maxY + EPSILON2) {
     distance6 = width + height + width + Math.max(0, Math.min(height, point.y - bounds.minY));
   } else {
     throw new Error(
@@ -3971,15 +4064,15 @@ function pointToAngle(point, bounds) {
     );
   }
   distance6 = Math.max(0, Math.min(perimeter, distance6));
-  return perimeter > EPSILON ? distance6 / perimeter * (2 * Math.PI) : 0;
+  return perimeter > EPSILON2 ? distance6 / perimeter * (2 * Math.PI) : 0;
 }
 function calculateSidePercentages(startAngle, endAngle, bounds) {
   const width = bounds.maxX - bounds.minX;
   const height = bounds.maxY - bounds.minY;
-  if (width < EPSILON && height < EPSILON)
+  if (width < EPSILON2 && height < EPSILON2)
     return { left: 0, top: 0, right: 0, bottom: 0 };
   const perimeter = 2 * (width + height);
-  if (perimeter < EPSILON) return { left: 0, top: 0, right: 0, bottom: 0 };
+  if (perimeter < EPSILON2) return { left: 0, top: 0, right: 0, bottom: 0 };
   const angleTopEnd = width / perimeter * (2 * Math.PI);
   const angleRightEnd = (width + height) / perimeter * (2 * Math.PI);
   const angleBottomEnd = (width + width + height) / perimeter * (2 * Math.PI);
@@ -3998,13 +4091,13 @@ function calculateSidePercentages(startAngle, endAngle, bounds) {
   ];
   const result = { left: 0, top: 0, right: 0, bottom: 0 };
   const totalAngleTraversal = endAngle - startAngle;
-  if (totalAngleTraversal < EPSILON) return result;
+  if (totalAngleTraversal < EPSILON2) return result;
   for (const side of sides) {
     const sideAngleRange = side.end - side.start;
-    if (sideAngleRange < EPSILON || side.length < EPSILON) continue;
+    if (sideAngleRange < EPSILON2 || side.length < EPSILON2) continue;
     const overlapStart = Math.max(startAngle, side.start);
     const overlapEnd = Math.min(endAngle, side.end);
-    if (overlapStart < overlapEnd - EPSILON) {
+    if (overlapStart < overlapEnd - EPSILON2) {
       const traversedAngleOnSide = overlapEnd - overlapStart;
       const percentage = traversedAngleOnSide / sideAngleRange;
       result[side.name] += Math.max(0, percentage);
@@ -5389,6 +5482,7 @@ var convertSrjToGraphicsObject = (srj) => {
   const circles = [];
   const points = [];
   const colorMap = getColorMap(srj);
+  const layerCount = 2;
   if (srj.connections) {
     for (const connection of srj.connections) {
       for (const point of connection.pointsToConnect) {
@@ -5396,6 +5490,7 @@ var convertSrjToGraphicsObject = (srj) => {
           x: point.x,
           y: point.y,
           color: colorMap[connection.name],
+          layer: point.layer ?? ("z" in point ? mapZToLayerName(point.z, layerCount) : "top"),
           label: `${connection.name} (${point.layer})`
         });
       }
@@ -5412,7 +5507,8 @@ var convertSrjToGraphicsObject = (srj) => {
             radius: 0.3,
             // 0.6 via diameter
             fill: "blue",
-            stroke: "none"
+            stroke: "none",
+            layer: "z0,1"
           });
         } else if (routePoint.route_type === "wire" && nextRoutePoint.route_type === "wire" && nextRoutePoint.layer === routePoint.layer) {
           lines.push({
@@ -5420,6 +5516,7 @@ var convertSrjToGraphicsObject = (srj) => {
               { x: routePoint.x, y: routePoint.y },
               { x: nextRoutePoint.x, y: nextRoutePoint.y }
             ],
+            layer: `z${mapLayerNameToZ(routePoint.layer, layerCount)}`,
             strokeWidth: 0.15,
             strokeColor: safeTransparentize(
               {
@@ -5443,7 +5540,8 @@ var convertSrjToGraphicsObject = (srj) => {
         center: o.center,
         width: o.width,
         height: o.height,
-        fill: "rgba(255,0,0,0.5)"
+        fill: "rgba(255,0,0,0.5)",
+        layer: `z${o.layers.map(mapLayerNameToZ).join(",")}`
       })
     ),
     circles,
@@ -5456,23 +5554,26 @@ var convertSrjToGraphicsObject = (srj) => {
 function getNodesNearNode(params) {
   const { nodeId, nodeIdToSegmentIds, segmentIdToNodeIds, hops } = params;
   if (hops === 0) return [nodeId];
-  const segments = nodeIdToSegmentIds.get(nodeId);
-  const nodes = /* @__PURE__ */ new Set();
-  for (const segmentId of segments) {
-    const adjacentNodeIds = segmentIdToNodeIds.get(segmentId);
-    for (const adjacentNodeId of adjacentNodeIds) {
-      const ancestors = getNodesNearNode({
-        nodeId: adjacentNodeId,
-        nodeIdToSegmentIds,
-        segmentIdToNodeIds,
-        hops: hops - 1
-      });
-      for (const ancestor of ancestors) {
-        nodes.add(ancestor);
+  const visitedNodes = /* @__PURE__ */ new Set([nodeId]);
+  const exploreQueue = [{ nodeId, remainingHops: hops }];
+  while (exploreQueue.length > 0) {
+    const { nodeId: node, remainingHops } = exploreQueue.shift();
+    if (remainingHops === 0) continue;
+    const segments = nodeIdToSegmentIds.get(node) || [];
+    for (const segmentId of segments) {
+      const adjacentNodeIds = segmentIdToNodeIds.get(segmentId) || [];
+      for (const adjacentNodeId of adjacentNodeIds) {
+        if (!visitedNodes.has(adjacentNodeId)) {
+          visitedNodes.add(adjacentNodeId);
+          exploreQueue.push({
+            nodeId: adjacentNodeId,
+            remainingHops: remainingHops - 1
+          });
+        }
       }
     }
   }
-  return Array.from(nodes);
+  return Array.from(visitedNodes);
 }
 
 // lib/solvers/UnravelSolver/createPointModificationsHash.ts
@@ -6257,7 +6358,7 @@ var getDedupedSegments = (assignedSegments) => {
   const dedupedSegPointMap = /* @__PURE__ */ new Map();
   let highestSegmentId = -1;
   for (const seg of assignedSegments) {
-    const segKey = `${seg.start.x}-${seg.start.y}-${seg.end.x}-${seg.end.y}`;
+    const segKey = `${seg.start.x}-${seg.start.y}-${seg.end.x}-${seg.end.y}-${seg.availableZ.join(",")}`;
     const existingSeg = dedupedSegPointMap.get(segKey);
     if (!existingSeg) {
       highestSegmentId++;
@@ -6271,36 +6372,48 @@ var getDedupedSegments = (assignedSegments) => {
   return dedupedSegments;
 };
 
-// lib/utils/getIntraNodeCrossingsFromSegments.ts
-var getIntraNodeCrossingsFromSegments = (segments) => {
+// lib/solvers/UnravelSolver/calculateCrossingProbabilityOfFailure.ts
+var calculateNodeProbabilityOfFailure = (node, numSameLayerCrossings, numEntryExitLayerChanges, numTransitionCrossings) => {
+  if (node?._containsTarget) return 0;
+  const totalCapacity = getTunedTotalCapacity1(node);
+  const estNumVias = numSameLayerCrossings * 0.82 + numEntryExitLayerChanges * 0.41 + numTransitionCrossings * 0.2;
+  const estUsedCapacity = (estNumVias / 2) ** 1.1;
+  const approxProb = estUsedCapacity / totalCapacity;
+  return approxProb;
+};
+
+// lib/utils/getIntraNodeCrossingsFromSegmentPoints.ts
+var getIntraNodeCrossingsFromSegmentPoints = (segmentPoints) => {
   let numSameLayerCrossings = 0;
-  const pointPairs = [];
-  const transitionPairPoints = [];
   let numEntryExitLayerChanges = 0;
-  const portPoints = segments.flatMap((seg) => seg.assignedPoints);
-  for (const { connectionName: aConnName, point: A } of portPoints) {
-    if (pointPairs.some((p) => p.connectionName === aConnName)) {
-      continue;
-    }
-    if (transitionPairPoints.some((p) => p.connectionName === aConnName)) {
-      continue;
+  let numTransitionCrossings = 0;
+  const connectionGroups = /* @__PURE__ */ new Map();
+  for (const point of segmentPoints) {
+    if (!connectionGroups.has(point.connectionName)) {
+      connectionGroups.set(point.connectionName, []);
     }
-    const pointPair = {
-      connectionName: aConnName,
-      z: A.z,
-      points: [A]
-    };
-    for (const { connectionName: bConnName, point: B } of portPoints) {
-      if (aConnName !== bConnName) continue;
-      if (A === B) continue;
-      pointPair.points.push(B);
-      if (pointPair.points.some((p) => p.z !== pointPair.z)) {
+    connectionGroups.get(point.connectionName).push(point);
+  }
+  const pointPairs = [];
+  const transitionPairPoints = [];
+  for (const [connectionName, points] of connectionGroups.entries()) {
+    if (points.length < 2) continue;
+    const firstPoint = points[0];
+    for (let i = 1; i < points.length; i++) {
+      const secondPoint = points[i];
+      const pointPair = {
+        connectionName,
+        z: firstPoint.z,
+        points: [firstPoint, secondPoint]
+      };
+      if (firstPoint.z !== secondPoint.z) {
         numEntryExitLayerChanges++;
-        transitionPairPoints.push(pointPair);
-        break;
+        transitionPairPoints.push({
+          connectionName,
+          points: [firstPoint, secondPoint]
+        });
       } else {
         pointPairs.push(pointPair);
-        break;
       }
     }
   }
@@ -6318,7 +6431,6 @@ var getIntraNodeCrossingsFromSegments = (segments) => {
       }
     }
   }
-  let numTransitionCrossings = 0;
   for (let i = 0; i < transitionPairPoints.length; i++) {
     for (let j = i + 1; j < transitionPairPoints.length; j++) {
       const pair1 = transitionPairPoints[i];
@@ -6354,16 +6466,6 @@ var getIntraNodeCrossingsFromSegments = (segments) => {
   };
 };
 
-// lib/solvers/UnravelSolver/calculateCrossingProbabilityOfFailure.ts
-var calculateNodeProbabilityOfFailure = (node, numSameLayerCrossings, numEntryExitLayerChanges, numTransitionCrossings) => {
-  if (node?._containsTarget) return 0;
-  const totalCapacity = getTunedTotalCapacity1(node);
-  const estNumVias = numSameLayerCrossings * 0.82 + numEntryExitLayerChanges * 0.41 + numTransitionCrossings * 0.2;
-  const estUsedCapacity = (estNumVias / 2) ** 1.1;
-  const approxProb = estUsedCapacity / totalCapacity;
-  return approxProb;
-};
-
 // lib/solvers/UnravelSolver/UnravelMultiSectionSolver.ts
 var UnravelMultiSectionSolver = class extends BaseSolver {
   nodeMap;
@@ -6437,8 +6539,10 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
       numSameLayerCrossings,
       numEntryExitLayerChanges,
       numTransitionCrossings
-    } = getIntraNodeCrossingsFromSegments(
-      this.nodeIdToSegmentIds.get(node.capacityMeshNodeId)?.map((segId) => this.dedupedSegmentMap.get(segId)) || []
+    } = getIntraNodeCrossingsFromSegmentPoints(
+      (this.nodeToSegmentPointMap.get(node.capacityMeshNodeId) ?? []).map(
+        (segPointId) => this.segmentPointMap.get(segPointId)
+      )
     );
     const probabilityOfFailure = calculateNodeProbabilityOfFailure(
       node,
@@ -6501,12 +6605,18 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
           segmentPoint.y = pointModification.y ?? segmentPoint.y;
           segmentPoint.z = pointModification.z ?? segmentPoint.z;
         }
-      }
-      for (const nodeId of this.activeSolver.unravelSection.allNodeIds) {
-        this.nodePfMap.set(
-          nodeId,
-          this.computeNodePf(this.nodeMap.get(nodeId))
-        );
+        const possiblyImpactedNodeIds = getNodesNearNode({
+          hops: this.activeSolver.MUTABLE_HOPS + 2,
+          nodeId: this.activeSolver.rootNodeId,
+          nodeIdToSegmentIds: this.nodeIdToSegmentIds,
+          segmentIdToNodeIds: this.segmentIdToNodeIds
+        });
+        for (const nodeId of possiblyImpactedNodeIds) {
+          this.nodePfMap.set(
+            nodeId,
+            this.computeNodePf(this.nodeMap.get(nodeId))
+          );
+        }
       }
       this.activeSolver = null;
     }
@@ -7337,7 +7447,7 @@ var CapacityNodeTree = class {
 };
 
 // lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts
-var EPSILON2 = 5e-3;
+var EPSILON3 = 5e-3;
 var SingleLayerNodeMergerSolver = class extends BaseSolver {
   nodeMap;
   currentBatchNodeIds;
@@ -7496,7 +7606,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToLeft.reduce((acc, adjNode) => {
           return acc + adjNode.height;
         }, 0) - rootNode.height
-      ) < EPSILON2;
+      ) < EPSILON3;
       if (leftAdjNodesTakeUpEntireHeight && leftAdjNodesAreAllSameSize) {
         rootNode.width += leftAdjNodeWidth;
         rootNode.center.x = rootNode.center.x - leftAdjNodeWidth / 2;
@@ -7516,7 +7626,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToRight.reduce((acc, adjNode) => {
           return acc + adjNode.height;
         }, 0) - rootNode.height
-      ) < EPSILON2;
+      ) < EPSILON3;
       if (rightAdjNodesTakeUpEntireHeight && rightAdjNodesAreAllSameSize) {
         rootNode.width += rightAdjNodeWidth;
         rootNode.center.x = rootNode.center.x + rightAdjNodeWidth / 2;
@@ -7536,7 +7646,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToTop.reduce((acc, adjNode) => {
           return acc + adjNode.width;
         }, 0) - rootNode.width
-      ) < EPSILON2;
+      ) < EPSILON3;
       if (topAdjNodesTakeUpEntireWidth && topAdjNodesAreAllSameSize) {
         rootNode.height += topAdjNodeHeight;
         rootNode.center.y = rootNode.center.y + topAdjNodeHeight / 2;
@@ -7556,7 +7666,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToBottom.reduce((acc, adjNode) => {
           return acc + adjNode.width;
         }, 0) - rootNode.width
-      ) < EPSILON2;
+      ) < EPSILON3;
       if (bottomAdjNodesTakeUpEntireWidth && bottomAdjNodesAreAllSameSize) {
         rootNode.height += bottomAdjNodeHeight;
         rootNode.center.y = rootNode.center.y - bottomAdjNodeHeight / 2;
@@ -7750,6 +7860,14 @@ var SingleSimplifiedPathSolver = class extends BaseSolver {
         });
       }
     }
+    if ("filteredObstaclePathSegments" in this) {
+      const filteredObstaclePathSegments = this.filteredObstaclePathSegments;
+      for (const [start, end] of filteredObstaclePathSegments) {
+        graphics.lines.push({
+          points: [start, end]
+        });
+      }
+    }
     return graphics;
   }
 };
@@ -7854,23 +7972,33 @@ var getSegmentBounds = (segment) => {
   };
 };
 var SegmentTree = class {
+  // traceThickness + obstacleMargin
   constructor(segments) {
     this.segments = segments;
     this.buckets = /* @__PURE__ */ new Map();
+    const segmentsById = /* @__PURE__ */ new Map();
     for (const segment of segments) {
+      const segmentKey = this.getSegmentKey(segment);
+      if (segmentsById.has(segmentKey)) continue;
+      segmentsById.set(segmentKey, segment);
       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 minIndexX = Math.floor(bounds.minX / this.CELL_SIZE);
+      const maxIndexX = Math.floor(bounds.maxX / this.CELL_SIZE);
+      const minIndexY = Math.floor(bounds.minY / this.CELL_SIZE);
+      const maxIndexY = Math.floor(bounds.maxY / this.CELL_SIZE);
+      for (let ix = minIndexX; ix <= maxIndexX; ix++) {
+        for (let iy = minIndexY; iy <= maxIndexY; iy++) {
+          const bucketKey = `${ix}x${iy}`;
           const bucket = this.buckets.get(bucketKey);
+          const segmentWithId = [
+            segment[0],
+            segment[1],
+            segmentKey
+          ];
           if (!bucket) {
-            this.buckets.set(bucketKey, [
-              [segment[0], segment[1], this.getSegmentKey(segment)]
-            ]);
+            this.buckets.set(bucketKey, [segmentWithId]);
           } else {
-            bucket.push([segment[0], segment[1], this.getSegmentKey(segment)]);
+            bucket.push(segmentWithId);
           }
         }
       }
@@ -7878,7 +8006,7 @@ var SegmentTree = class {
   }
   buckets;
   CELL_SIZE = 0.4;
-  SEGMENT_MARGIN = 0.2;
+  SEGMENT_MARGIN = 0.4;
   getBucketKey(x, y) {
     return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
   }
@@ -7892,17 +8020,22 @@ var SegmentTree = class {
     const minY = Math.min(A.y, B.y) - this.SEGMENT_MARGIN;
     const maxX = Math.max(A.x, B.x) + this.SEGMENT_MARGIN;
     const maxY = Math.max(A.y, B.y) + this.SEGMENT_MARGIN;
-    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);
+    const minIndexX = Math.floor(minX / this.CELL_SIZE);
+    const maxIndexX = Math.floor(maxX / this.CELL_SIZE);
+    const minIndexY = Math.floor(minY / this.CELL_SIZE);
+    const maxIndexY = Math.floor(maxY / this.CELL_SIZE);
+    for (let ix = minIndexX; ix <= maxIndexX; ix++) {
+      for (let iy = minIndexY; iy <= maxIndexY; iy++) {
+        const bucketKey = `${ix}x${iy}`;
+        const bucket = this.buckets.get(bucketKey);
+        if (bucket) {
+          for (const segment of bucket) {
+            const key = segment[2];
+            if (!alreadyAddedSegments.has(key)) {
+              alreadyAddedSegments.add(key);
+              segments.push(segment);
+            }
+          }
         }
       }
     }