@tscircuit/capacity-autorouter 0.0.42 → 0.0.44

package/dist/index.js

@@ -68,6 +68,9 @@ var BaseSolver = class {
   }
   _step() {
   }
+  getConstructorParams() {
+    throw new Error("getConstructorParams not implemented");
+  }
   solve() {
     const startTime = Date.now();
     while (!this.solved && !this.failed) {
@@ -1639,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(",")}`
+            )
           });
         }
       });
@@ -1707,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);
     }
   }
@@ -1844,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) {
@@ -1938,6 +2006,86 @@ function distance(p1, p2) {
   return Math.sqrt(dx * dx + dy * dy);
 }
 
+// node_modules/@tscircuit/math-utils/dist/chunk-MHHTZHOJ.js
+function getBoundingBox(box) {
+  const halfWidth = box.width / 2;
+  const halfHeight = box.height / 2;
+  return {
+    minX: box.center.x - halfWidth,
+    maxX: box.center.x + halfWidth,
+    minY: box.center.y - halfHeight,
+    maxY: box.center.y + halfHeight
+  };
+}
+function computeDistanceBetweenBoxes(boxA, boxB) {
+  const a = getBoundingBox(boxA);
+  const b = getBoundingBox(boxB);
+  const dx = Math.max(a.minX - b.maxX, b.minX - a.maxX, 0);
+  const dy = Math.max(a.minY - b.maxY, b.minY - a.maxY, 0);
+  const pointA = { x: 0, y: 0 };
+  const pointB = { x: 0, y: 0 };
+  if (dx === 0 && dy === 0) {
+    return { distance: 0, pointA: boxA.center, pointB: boxB.center };
+  }
+  pointA.x = clamp(boxA.center.x, b.minX, b.maxX);
+  pointA.y = clamp(boxA.center.y, b.minY, b.maxY);
+  pointB.x = clamp(boxB.center.x, a.minX, a.maxX);
+  pointB.y = clamp(boxB.center.y, a.minY, a.maxY);
+  const distance6 = Math.hypot(pointA.x - pointB.x, pointA.y - pointB.y);
+  return { distance: distance6, pointA, pointB };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// node_modules/@tscircuit/math-utils/dist/chunk-OMVVSGKD.js
+function segmentToBoundsMinDistance(a, b, bounds) {
+  const topLeft = { x: bounds.minX, y: bounds.minY };
+  const topRight = { x: bounds.maxX, y: bounds.minY };
+  const bottomLeft = { x: bounds.minX, y: bounds.maxY };
+  const bottomRight = { x: bounds.maxX, y: bounds.maxY };
+  if (doSegmentsIntersect(a, b, topLeft, topRight) || doSegmentsIntersect(a, b, topRight, bottomRight) || doSegmentsIntersect(a, b, bottomRight, bottomLeft) || doSegmentsIntersect(a, b, bottomLeft, topLeft)) {
+    return 0;
+  }
+  if (a.x >= bounds.minX && a.x <= bounds.maxX && a.y >= bounds.minY && a.y <= bounds.maxY && b.x >= bounds.minX && b.x <= bounds.maxX && b.y >= bounds.minY && b.y <= bounds.maxY) {
+    return 0;
+  }
+  const distances = [
+    pointToSegmentDistance(topLeft, a, b),
+    pointToSegmentDistance(topRight, a, b),
+    pointToSegmentDistance(bottomLeft, a, b),
+    pointToSegmentDistance(bottomRight, a, b)
+  ];
+  if (a.x >= bounds.minX && a.x <= bounds.maxX && a.y >= bounds.minY && a.y <= bounds.maxY) {
+    return 0;
+  }
+  if (b.x >= bounds.minX && b.x <= bounds.maxX && b.y >= bounds.minY && b.y <= bounds.maxY) {
+    return 0;
+  }
+  if (a.x < bounds.minX || a.x > bounds.maxX || a.y < bounds.minY || a.y > bounds.maxY) {
+    const closestX = clamp(a.x, bounds.minX, bounds.maxX);
+    const closestY = clamp(a.y, bounds.minY, bounds.maxY);
+    distances.push(distance(a, { x: closestX, y: closestY }));
+  }
+  if (b.x < bounds.minX || b.x > bounds.maxX || b.y < bounds.minY || b.y > bounds.maxY) {
+    const closestX = clamp(b.x, bounds.minX, bounds.maxX);
+    const closestY = clamp(b.y, bounds.minY, bounds.maxY);
+    distances.push(distance(b, { x: closestX, y: closestY }));
+  }
+  return Math.min(...distances);
+}
+function segmentToBoxMinDistance(a, b, box) {
+  const halfWidth = box.width / 2;
+  const halfHeight = box.height / 2;
+  const bounds = {
+    minX: box.center.x - halfWidth,
+    maxX: box.center.x + halfWidth,
+    minY: box.center.y - halfHeight,
+    maxY: box.center.y + halfHeight
+  };
+  return segmentToBoundsMinDistance(a, b, bounds);
+}
+
 // lib/data-structures/SingleRouteCandidatePriorityQueue.ts
 var SingleRouteCandidatePriorityQueue = class {
   heap = [];
@@ -1992,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();
@@ -2074,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;
@@ -2106,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;
@@ -2385,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({
@@ -3573,13 +3749,13 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     x: (A.x + B.x + C.x) / 3,
     y: (A.y + B.y + C.y) / 3
   };
-  const distance5 = (p1, p2) => {
+  const distance6 = (p1, p2) => {
     return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
   };
   const isValidPoint = (point) => {
-    const distToA = distance5(point, A);
-    const distToB = distance5(point, B);
-    const distToC = distance5(point, C);
+    const distToA = distance6(point, A);
+    const distToB = distance6(point, B);
+    const distToC = distance6(point, C);
     const withinBounds = point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY;
     return distToA >= radius && distToB >= radius && distToC >= radius && withinBounds;
   };
@@ -3623,10 +3799,10 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     };
     const result = [];
     const epsilon = 1e-6;
-    if (Math.abs(distance5(intersection1, c1) - r) < epsilon && Math.abs(distance5(intersection1, c2) - r) < epsilon) {
+    if (Math.abs(distance6(intersection1, c1) - r) < epsilon && Math.abs(distance6(intersection1, c2) - r) < epsilon) {
       result.push(intersection1);
     }
-    if (Math.abs(distance5(intersection2, c1) - r) < epsilon && Math.abs(distance5(intersection2, c2) - r) < epsilon) {
+    if (Math.abs(distance6(intersection2, c1) - r) < epsilon && Math.abs(distance6(intersection2, c2) - r) < epsilon) {
       result.push(intersection2);
     }
     return result;
@@ -3650,7 +3826,7 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     const interiorCandidates = validCandidates.filter((p) => !isOnBoundary(p));
     if (interiorCandidates.length > 0) {
       interiorCandidates.sort(
-        (a, b) => distance5(a, avgPoint) - distance5(b, avgPoint)
+        (a, b) => distance6(a, avgPoint) - distance6(b, avgPoint)
       );
       return interiorCandidates[0];
     }
@@ -3662,7 +3838,7 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
     for (let y = bounds.minY + 1; y < bounds.maxY; y += gridStep) {
       const point = { x, y };
       if (isValidPoint(point)) {
-        const dist = distance5(point, avgPoint);
+        const dist = distance6(point, avgPoint);
         if (dist < bestDistance) {
           bestDistance = dist;
           bestPoint = point;
@@ -3697,7 +3873,7 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
   const validBoundaryPoints = boundaryPoints.filter(isValidPoint);
   if (validBoundaryPoints.length > 0) {
     validBoundaryPoints.sort(
-      (a, b) => distance5(a, avgPoint) - distance5(b, avgPoint)
+      (a, b) => distance6(a, avgPoint) - distance6(b, avgPoint)
     );
     return validBoundaryPoints[0];
   }
@@ -3705,9 +3881,9 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
   let leastBadPoint = { x: bounds.minX, y: bounds.minY };
   for (const point of [...allCandidates, ...boundaryPoints]) {
     if (point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY) {
-      const violationA = Math.max(0, radius - distance5(point, A));
-      const violationB = Math.max(0, radius - distance5(point, B));
-      const violationC = Math.max(0, radius - distance5(point, C));
+      const violationA = Math.max(0, radius - distance6(point, A));
+      const violationB = Math.max(0, radius - distance6(point, B));
+      const violationC = Math.max(0, radius - distance6(point, C));
       const totalViolation = violationA + violationB + violationC;
       if (totalViolation < minViolation) {
         minViolation = totalViolation;
@@ -3722,12 +3898,62 @@ function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
 function findPointToGetAroundCircle(A, C, Q) {
   const B = computeTangentPoint(C, A, Q.center, Q.radius);
   const D = computeTangentPoint(A, C, Q.center, Q.radius);
-  const E = computeIntersection(
-    { x: C.x, y: C.y },
-    { x: B.x, y: B.y },
-    { x: A.x, y: A.y },
-    { x: D.x, y: D.y }
-  );
+  const distBC = distance2(B, C);
+  const distAD = distance2(A, D);
+  const minDistThreshold = 1e-6;
+  const BIsValid = distBC > minDistThreshold;
+  const DIsValid = distAD > minDistThreshold;
+  let E;
+  if (!BIsValid || !DIsValid) {
+    const midAC = {
+      x: (A.x + C.x) / 2,
+      y: (A.y + C.y) / 2
+    };
+    const distFromCenter = distance2(midAC, Q.center);
+    if (distFromCenter < Q.radius * 1.1) {
+      const dirFromCenter = {
+        x: (midAC.x - Q.center.x) / distFromCenter,
+        y: (midAC.y - Q.center.y) / distFromCenter
+      };
+      E = {
+        x: Q.center.x + dirFromCenter.x * Q.radius * 1.2,
+        y: Q.center.y + dirFromCenter.y * Q.radius * 1.2
+      };
+    } else {
+      E = midAC;
+    }
+  } else {
+    E = {
+      x: (B.x + D.x) / 2,
+      y: (B.y + D.y) / 2
+    };
+    const distBE = distance2(B, E);
+    const distDE = distance2(D, E);
+    if (Math.abs(distBE - distDE) > Math.min(distBE, distDE) * 0.5) {
+      const distAB = distance2(A, B);
+      const distCD = distance2(C, D);
+      const totalDist = distAB + distCD;
+      if (totalDist > minDistThreshold) {
+        const weightB = distCD / totalDist;
+        const weightD = distAB / totalDist;
+        E = {
+          x: B.x * weightB + D.x * weightD,
+          y: B.y * weightB + D.y * weightD
+        };
+      }
+    }
+    const distEToCenter = distance2(E, Q.center);
+    if (distEToCenter < Q.radius * 1.05) {
+      const dirFromCenter = {
+        x: (E.x - Q.center.x) / distEToCenter,
+        y: (E.y - Q.center.y) / distEToCenter
+      };
+      E = {
+        x: Q.center.x + dirFromCenter.x * Q.radius * 1.2,
+        y: Q.center.y + dirFromCenter.y * Q.radius * 1.2
+      };
+    }
+  }
   return { B, D, E };
 }
 function computeTangentPoint(observationPoint, referencePoint, circleCenter, radius) {
@@ -3736,8 +3962,29 @@ function computeTangentPoint(observationPoint, referencePoint, circleCenter, rad
     circleCenter.y - observationPoint.y
   ];
   const CQLength = Math.sqrt(CQ[0] * CQ[0] + CQ[1] * CQ[1]);
-  if (CQLength < radius) {
-    return observationPoint;
+  if (CQLength <= radius) {
+    if (CQLength < 1e-8) {
+      const refVec = [
+        referencePoint.x - observationPoint.x,
+        referencePoint.y - observationPoint.y
+      ];
+      const refLength = Math.sqrt(refVec[0] * refVec[0] + refVec[1] * refVec[1]);
+      if (refLength < 1e-8) {
+        return {
+          x: circleCenter.x + radius,
+          y: circleCenter.y
+        };
+      }
+      return {
+        x: circleCenter.x + refVec[0] / refLength * radius,
+        y: circleCenter.y + refVec[1] / refLength * radius
+      };
+    }
+    const CQUnit2 = [CQ[0] / CQLength, CQ[1] / CQLength];
+    return {
+      x: circleCenter.x - CQUnit2[0] * radius,
+      y: circleCenter.y - CQUnit2[1] * radius
+    };
   }
   const CR = [
     referencePoint.x - observationPoint.x,
@@ -3761,23 +4008,108 @@ function computeTangentPoint(observationPoint, referencePoint, circleCenter, rad
     y: observationPoint.y + d * unitToTangent[1]
   };
 }
-function computeIntersection(p1, p2, p3, p4) {
-  const a1 = p2.y - p1.y;
-  const b1 = p1.x - p2.x;
-  const c1 = a1 * p1.x + b1 * p1.y;
-  const a2 = p4.y - p3.y;
-  const b2 = p3.x - p4.x;
-  const c2 = a2 * p3.x + b2 * p3.y;
-  const det = a1 * b2 - a2 * b1;
-  if (Math.abs(det) < 1e-8) {
-    return {
-      x: (p1.x + p3.x) / 2,
-      y: (p1.y + p3.y) / 2
-    };
+function distance2(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/calculateSideTraversal.ts
+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) < EPSILON2) {
+    return { left: 0, top: 0, right: 0, bottom: 0 };
+  }
+  return calculateSidePercentages(startAngle, endAngle, bounds);
+}
+function calculateTraversalPercentages(A, B, C, bounds) {
+  const percentagesAB = calculateSegmentTraversal(A, B, bounds);
+  const percentagesBC = calculateSegmentTraversal(B, C, bounds);
+  const totalPercentages = {
+    left: Math.min(1, percentagesAB.left + percentagesBC.left),
+    top: Math.min(1, percentagesAB.top + percentagesBC.top),
+    right: Math.min(1, percentagesAB.right + percentagesBC.right),
+    bottom: Math.min(1, percentagesAB.bottom + percentagesBC.bottom)
+  };
+  for (const key in totalPercentages) {
+    if (Math.abs(totalPercentages[key]) < EPSILON2) {
+      totalPercentages[key] = 0;
+    }
+  }
+  return totalPercentages;
+}
+function pointToAngle(point, bounds) {
+  const width = bounds.maxX - bounds.minX;
+  const height = bounds.maxY - bounds.minY;
+  if (width < EPSILON2 && height < EPSILON2) return 0;
+  const perimeter = 2 * (width + height);
+  if (perimeter < EPSILON2) return 0;
+  let distance6 = 0;
+  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) < 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) < 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) < 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(
+      `Point (${point.x}, ${point.y}) does not lie on the boundary defined by ${JSON.stringify(bounds)}`
+    );
+  }
+  distance6 = Math.max(0, Math.min(perimeter, distance6));
+  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 < EPSILON2 && height < EPSILON2)
+    return { left: 0, top: 0, right: 0, bottom: 0 };
+  const perimeter = 2 * (width + height);
+  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);
+  const angleLeftEnd = 2 * Math.PI;
+  const sides = [
+    { name: "top", start: 0, end: angleTopEnd, length: width },
+    { name: "right", start: angleTopEnd, end: angleRightEnd, length: height },
+    {
+      name: "bottom",
+      start: angleRightEnd,
+      end: angleBottomEnd,
+      length: width
+    },
+    { name: "left", start: angleBottomEnd, end: angleLeftEnd, length: height }
+    // Ends at 2PI
+  ];
+  const result = { left: 0, top: 0, right: 0, bottom: 0 };
+  const totalAngleTraversal = endAngle - startAngle;
+  if (totalAngleTraversal < EPSILON2) return result;
+  for (const side of sides) {
+    const sideAngleRange = side.end - side.start;
+    if (sideAngleRange < EPSILON2 || side.length < EPSILON2) continue;
+    const overlapStart = Math.max(startAngle, side.start);
+    const overlapEnd = Math.min(endAngle, side.end);
+    if (overlapStart < overlapEnd - EPSILON2) {
+      const traversedAngleOnSide = overlapEnd - overlapStart;
+      const percentage = traversedAngleOnSide / sideAngleRange;
+      result[side.name] += Math.max(0, percentage);
+    }
+  }
+  for (const key in result) {
+    result[key] = Math.max(
+      0,
+      Math.min(1, result[key])
+    );
   }
-  const x = (b2 * c1 - b1 * c2) / det;
-  const y = (a1 * c2 - a2 * c1) / det;
-  return { x, y };
+  return result;
 }
 
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/SingleTransitionCrossingRouteSolver.ts
@@ -3864,17 +4196,30 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
     const ntrP1 = transitionRoute.A.z !== flatRouteZ ? transitionRoute.A : transitionRoute.B;
     const marginFromBorderWithTrace = this.obstacleMargin * 2 + this.viaDiameter / 2 + this.traceThickness;
     const marginFromBorderWithoutTrace = this.obstacleMargin + this.viaDiameter / 2;
+    const A = flatRoute.A;
+    const B = ntrP1;
+    const C = flatRoute.B;
+    const sideTraversal = calculateTraversalPercentages(A, B, C, this.bounds);
+    const viaBounds = {
+      minX: this.bounds.minX + (sideTraversal.left > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
+      minY: this.bounds.minY + (sideTraversal.bottom > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
+      maxX: this.bounds.maxX - (sideTraversal.right > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
+      maxY: this.bounds.maxY - (sideTraversal.top > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace)
+    };
+    if (viaBounds.maxY < viaBounds.minY) {
+      viaBounds.minY = (viaBounds.minY + viaBounds.maxY) / 2;
+      viaBounds.maxY = viaBounds.minY;
+    }
+    if (viaBounds.maxX < viaBounds.minX) {
+      viaBounds.minX = (viaBounds.minX + viaBounds.maxX) / 2;
+      viaBounds.maxX = viaBounds.minX;
+    }
     return findClosestPointToABCWithinBounds(
-      flatRoute.A,
-      flatRoute.B,
-      ntrP1,
+      A,
+      B,
+      C,
       marginFromBorderWithTrace,
-      {
-        minX: this.bounds.minX + marginFromBorderWithoutTrace,
-        minY: this.bounds.minY + marginFromBorderWithoutTrace,
-        maxX: this.bounds.maxX - marginFromBorderWithTrace,
-        maxY: this.bounds.maxY - marginFromBorderWithTrace
-      }
+      viaBounds
     );
   }
   /**
@@ -4662,13 +5007,13 @@ function buildMinimumSpanningTree(points) {
       if (point.x === neighbor.x && point.y === neighbor.y) {
         continue;
       }
-      const distance5 = Math.sqrt(
+      const distance6 = Math.sqrt(
         (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
       );
       edges.push({
         from: point,
         to: neighbor,
-        weight: distance5
+        weight: distance6
       });
     }
   }
@@ -5137,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) {
@@ -5144,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})`
         });
       }
@@ -5160,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({
@@ -5168,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(
               {
@@ -5191,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,
@@ -5204,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
@@ -6005,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++;
@@ -6019,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;
       }
     }
   }
@@ -6066,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];
@@ -6102,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;
@@ -6185,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,
@@ -6249,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;
     }
@@ -6489,11 +6851,11 @@ var CapacityPathingSolver = class extends BaseSolver {
         let closestNode = this.nodes[0];
         let minDistance = Number.MAX_VALUE;
         for (const node of nodesWithTargets) {
-          const distance5 = Math.sqrt(
+          const distance6 = Math.sqrt(
             (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
           );
-          if (distance5 < minDistance) {
-            minDistance = distance5;
+          if (distance6 < minDistance) {
+            minDistance = distance6;
             closestNode = node;
           }
         }
@@ -7085,7 +7447,7 @@ var CapacityNodeTree = class {
 };
 
 // lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts
-var EPSILON = 5e-3;
+var EPSILON3 = 5e-3;
 var SingleLayerNodeMergerSolver = class extends BaseSolver {
   nodeMap;
   currentBatchNodeIds;
@@ -7244,7 +7606,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToLeft.reduce((acc, adjNode) => {
           return acc + adjNode.height;
         }, 0) - rootNode.height
-      ) < EPSILON;
+      ) < EPSILON3;
       if (leftAdjNodesTakeUpEntireHeight && leftAdjNodesAreAllSameSize) {
         rootNode.width += leftAdjNodeWidth;
         rootNode.center.x = rootNode.center.x - leftAdjNodeWidth / 2;
@@ -7264,7 +7626,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToRight.reduce((acc, adjNode) => {
           return acc + adjNode.height;
         }, 0) - rootNode.height
-      ) < EPSILON;
+      ) < EPSILON3;
       if (rightAdjNodesTakeUpEntireHeight && rightAdjNodesAreAllSameSize) {
         rootNode.width += rightAdjNodeWidth;
         rootNode.center.x = rootNode.center.x + rightAdjNodeWidth / 2;
@@ -7284,7 +7646,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToTop.reduce((acc, adjNode) => {
           return acc + adjNode.width;
         }, 0) - rootNode.width
-      ) < EPSILON;
+      ) < EPSILON3;
       if (topAdjNodesTakeUpEntireWidth && topAdjNodesAreAllSameSize) {
         rootNode.height += topAdjNodeHeight;
         rootNode.center.y = rootNode.center.y + topAdjNodeHeight / 2;
@@ -7304,7 +7666,7 @@ var SingleLayerNodeMergerSolver = class extends BaseSolver {
         adjacentNodesToBottom.reduce((acc, adjNode) => {
           return acc + adjNode.width;
         }, 0) - rootNode.width
-      ) < EPSILON;
+      ) < EPSILON3;
       if (bottomAdjNodesTakeUpEntireWidth && bottomAdjNodesAreAllSameSize) {
         rootNode.height += bottomAdjNodeHeight;
         rootNode.center.y = rootNode.center.y - bottomAdjNodeHeight / 2;
@@ -7401,6 +7763,15 @@ var SingleSimplifiedPathSolver = class extends BaseSolver {
     this.newRoute = [this.inputRoute.route[0]];
     this.newVias = [];
   }
+  getConstructorParams() {
+    return {
+      inputRoute: this.inputRoute,
+      otherHdRoutes: this.otherHdRoutes,
+      obstacles: this.obstacles,
+      connMap: this.connMap.netMap,
+      colorMap: this.colorMap
+    };
+  }
   get simplifiedRoute() {
     return {
       connectionName: this.inputRoute.connectionName,
@@ -7489,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;
   }
 };
@@ -7541,23 +7920,23 @@ function pointToSegmentDistance4(P, Q1, Q2) {
   const w = { x: P.x - Q1.x, y: P.y - Q1.y };
   const c1 = dotProduct(w, v);
   if (c1 <= 0) {
-    return distance4(P, Q1);
+    return distance5(P, Q1);
   }
   const c2 = dotProduct(v, v);
   if (c2 <= c1) {
-    return distance4(P, Q2);
+    return distance5(P, Q2);
   }
   const b = c1 / c2;
   const Pb = {
     x: Q1.x + b * v.x,
     y: Q1.y + b * v.y
   };
-  return distance4(P, Pb);
+  return distance5(P, Pb);
 }
 function dotProduct(v1, v2) {
   return v1.x * v2.x + v1.y * v2.y;
 }
-function distance4(p1, p2) {
+function distance5(p1, p2) {
   const dx = p2.x - p1.x;
   const dy = p2.y - p1.y;
   return Math.sqrt(dx * dx + dy * dy);
@@ -7593,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);
           }
         }
       }
@@ -7617,6 +8006,7 @@ var SegmentTree = class {
   }
   buckets;
   CELL_SIZE = 0.4;
+  SEGMENT_MARGIN = 0.4;
   getBucketKey(x, y) {
     return `${Math.floor(x / this.CELL_SIZE)}x${Math.floor(y / this.CELL_SIZE)}`;
   }
@@ -7626,21 +8016,26 @@ var SegmentTree = class {
   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);
+    const minX = Math.min(A.x, B.x) - this.SEGMENT_MARGIN;
+    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 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);
+            }
+          }
         }
       }
     }
@@ -7669,7 +8064,8 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
   filteredObstaclePathSegments = [];
   filteredVias = [];
   segmentTree;
-  OBSTACLE_MARGIN = 0.15;
+  OBSTACLE_MARGIN = 0.1;
+  TRACE_THICKNESS = 0.15;
   TAIL_JUMP_RATIO = 0.8;
   constructor(params) {
     super(params);
@@ -7689,6 +8085,14 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       },
       { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity }
     );
+    const boundsBox = {
+      center: {
+        x: (bounds.minX + bounds.maxX) / 2,
+        y: (bounds.minY + bounds.maxY) / 2
+      },
+      width: bounds.maxX - bounds.minX,
+      height: bounds.maxY - bounds.minY
+    };
     this.filteredObstacles = this.obstacles.filter(
       (obstacle) => !obstacle.connectedTo.some(
         (id) => this.connMap.areIdsConnected(this.inputRoute.connectionName, id)
@@ -7699,11 +8103,11 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       )) {
         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;
+      const { distance: distance6 } = computeDistanceBetweenBoxes(boundsBox, obstacle);
+      if (distance6 < this.OBSTACLE_MARGIN + 0.5) {
+        return true;
+      }
+      return false;
     });
     this.filteredObstaclePathSegments = this.otherHdRoutes.flatMap(
       (hdRoute) => {
@@ -7775,15 +8179,15 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     return p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
   }
   // Get point at a specific distance along the path
-  getPointAtDistance(distance5) {
-    distance5 = Math.max(0, Math.min(distance5, this.totalPathLength));
+  getPointAtDistance(distance6) {
+    distance6 = Math.max(0, Math.min(distance6, this.totalPathLength));
     const segment = this.pathSegments.find(
-      (seg) => distance5 >= seg.startDistance && distance5 <= seg.endDistance
+      (seg) => distance6 >= seg.startDistance && distance6 <= seg.endDistance
     );
     if (!segment) {
       return this.inputRoute.route[this.inputRoute.route.length - 1];
     }
-    const factor = (distance5 - segment.startDistance) / segment.length;
+    const factor = (distance6 - segment.startDistance) / segment.length;
     return {
       x: segment.start.x + factor * (segment.end.x - segment.start.x),
       y: segment.start.y + factor * (segment.end.y - segment.start.y),
@@ -7792,17 +8196,17 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     };
   }
   // Find nearest index in the original route for a given distance
-  getNearestIndexForDistance(distance5) {
-    if (distance5 <= 0) return 0;
-    if (distance5 >= this.totalPathLength)
+  getNearestIndexForDistance(distance6) {
+    if (distance6 <= 0) return 0;
+    if (distance6 >= this.totalPathLength)
       return this.inputRoute.route.length - 1;
     const segmentIndex = this.pathSegments.findIndex(
-      (seg) => distance5 >= seg.startDistance && distance5 <= seg.endDistance
+      (seg) => distance6 >= seg.startDistance && distance6 <= seg.endDistance
     );
     if (segmentIndex === -1) return 0;
     const segment = this.pathSegments[segmentIndex];
     const midDistance = (segment.startDistance + segment.endDistance) / 2;
-    return distance5 > midDistance ? segmentIndex + 1 : segmentIndex;
+    return distance6 > midDistance ? segmentIndex + 1 : segmentIndex;
   }
   // Check if a path segment is valid
   isValidPathSegment(start, end) {
@@ -7810,49 +8214,27 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       if (!obstacle.zLayers?.includes(start.z)) {
         continue;
       }
-      const obstacleLeft = obstacle.center.x - obstacle.width / 2 - this.OBSTACLE_MARGIN;
-      const obstacleRight = obstacle.center.x + obstacle.width / 2 + this.OBSTACLE_MARGIN;
-      const obstacleTop = obstacle.center.y - obstacle.height / 2 - this.OBSTACLE_MARGIN;
-      const obstacleBottom = obstacle.center.y + obstacle.height / 2 + this.OBSTACLE_MARGIN;
-      if (doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleLeft, y: obstacleTop },
-        { x: obstacleRight, y: obstacleTop }
-      ) || doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleRight, y: obstacleTop },
-        { x: obstacleRight, y: obstacleBottom }
-      ) || doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleRight, y: obstacleBottom },
-        { x: obstacleLeft, y: obstacleBottom }
-      ) || doSegmentsIntersect(
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y },
-        { x: obstacleLeft, y: obstacleBottom },
-        { x: obstacleLeft, y: obstacleTop }
-      )) {
+      const distToObstacle = segmentToBoxMinDistance(start, end, obstacle);
+      if (distToObstacle < this.OBSTACLE_MARGIN + this.TRACE_THICKNESS / 2) {
         return false;
       }
     }
     const segmentsThatCouldIntersect = this.segmentTree.getSegmentsThatCouldIntersect(start, end);
-    for (const [otherSegA, otherSegB] of segmentsThatCouldIntersect) {
+    for (const [otherSegA, otherSegB, segId] of segmentsThatCouldIntersect) {
       if (otherSegA.z === start.z && otherSegB.z === start.z) {
-        if (minimumDistanceBetweenSegments(
+        const distBetweenSegments = 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) {
+        );
+        if (distBetweenSegments < this.OBSTACLE_MARGIN + this.TRACE_THICKNESS) {
           return false;
         }
       }
     }
     for (const via of this.filteredVias) {
-      if (pointToSegmentDistance(via, start, end) < this.OBSTACLE_MARGIN + via.diameter / 2) {
+      if (pointToSegmentDistance(via, start, end) < this.OBSTACLE_MARGIN + via.diameter / 2 + this.TRACE_THICKNESS / 2) {
         return false;
       }
     }
@@ -7904,10 +8286,10 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     }
     this.currentStepSize = this.maxStepSize;
   }
-  moveHead(distance5) {
-    this.lastHeadMoveDistance = distance5;
+  moveHead(distance6) {
+    this.lastHeadMoveDistance = distance6;
     this.headDistanceAlongPath = Math.min(
-      this.headDistanceAlongPath + distance5,
+      this.headDistanceAlongPath + distance6,
       this.totalPathLength
     );
   }
@@ -8045,9 +8427,9 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       color: "red",
       label: ["Tentative Head", `z: ${tentativeHead.z}`].join("\n")
     });
-    let distance5 = 0;
-    while (distance5 < this.totalPathLength) {
-      const point = this.getPointAtDistance(distance5);
+    let distance6 = 0;
+    while (distance6 < this.totalPathLength) {
+      const point = this.getPointAtDistance(distance6);
       graphics.circles.push({
         center: {
           x: point.x,
@@ -8056,7 +8438,7 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
         radius: 0.05,
         fill: "rgba(100, 100, 100, 0.5)"
       });
-      distance5 += this.totalPathLength / 20;
+      distance6 += this.totalPathLength / 20;
     }
     if (this.lastValidPath && this.lastValidPath.length > 1) {
       for (let i = 0; i < this.lastValidPath.length - 1; i++) {