@tscircuit/schematic-trace-solver 0.0.107 → 0.0.109

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS12 = 1e-9;
+  const EPS13 = 1e-9;
   const crossesSegment = (a, b) => {
     for (const [, rcl] of restrictedCenterLines) {
       if (rcl.axes.has("x") && typeof rcl.x === "number") {
-        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS12) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS13) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS12) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS13) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS12 || Math.abs(p1.y - p2.y) < EPS12) {
+  if (Math.abs(p1.x - p2.x) < EPS13 || Math.abs(p1.y - p2.y) < EPS13) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -421,6 +421,7 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
 }
 
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
+var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
 var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
 var MspConnectionPairSolver = class extends BaseSolver {
   inputProblem;
@@ -436,7 +437,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
-    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? 1;
+    this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
     const { directConnMap, netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
     this.dcConnMap = directConnMap;
     this.globalConnMap = netConnMap;
@@ -630,6 +631,25 @@ function getRectBounds(center, w, h) {
   };
 }
 
+// lib/utils/textBoxBounds.ts
+function getTextBoxBounds(textBox, padding = {}) {
+  return {
+    minX: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
+    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
+    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
+    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0)
+  };
+}
+function boundsOverlap(a, b, eps = 1e-9) {
+  return a.minX < b.maxX - eps && a.maxX > b.minX + eps && a.minY < b.maxY - eps && a.maxY > b.minY + eps;
+}
+function rectIntersectsAnyTextBox(bounds, inputProblem) {
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
+  }
+  return false;
+}
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/calculateDirectShortPath.ts
 import { calculateElbow } from "calculate-elbow";
 var MAX_SHORT_TRACE_DISTANCE = 0.15;
@@ -875,12 +895,8 @@ var candidateMidsFromSet = (axis, colliding, collisionRects, aabb, opts = {}) =>
   }
 };
 
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours.ts
-var getSegmentAxis = (start, end) => {
-  if (isVertical(start, end)) return "x";
-  if (isHorizontal(start, end)) return "y";
-  return null;
-};
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts
+var EPS3 = 1e-9;
 var hasOnlyNonzeroOrthogonalSegments = (path) => path.every((point, index) => {
   const nextPoint = path[index + 1];
   if (!nextPoint) return true;
@@ -889,57 +905,6 @@ var hasOnlyNonzeroOrthogonalSegments = (path) => path.every((point, index) => {
   }
   return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0;
 });
-var generateEndpointCollisionDetours = ({
-  path,
-  collidingSegmentIndex,
-  obstacle
-}) => {
-  if (path.length < 3 || path.length > 4) return [];
-  const lastSegmentIndex = path.length - 2;
-  if (collidingSegmentIndex !== 0 && collidingSegmentIndex !== lastSegmentIndex) {
-    return [];
-  }
-  const shouldReverse = collidingSegmentIndex === lastSegmentIndex;
-  const orderedPath = shouldReverse ? [...path].reverse() : path;
-  const [start, corner, end] = orderedPath;
-  const firstSegmentAxis = getSegmentAxis(start, corner);
-  const secondSegmentAxis = getSegmentAxis(corner, end);
-  if (!firstSegmentAxis || !secondSegmentAxis) return [];
-  if (firstSegmentAxis === secondSegmentAxis) return [];
-  const escapeCoordinates = [
-    ...midBetweenPointAndRect(secondSegmentAxis, start, obstacle),
-    ...midBetweenPointAndRect(secondSegmentAxis, end, obstacle)
-  ];
-  const detourCoordinates = [
-    ...midBetweenPointAndRect(firstSegmentAxis, start, obstacle),
-    ...midBetweenPointAndRect(firstSegmentAxis, end, obstacle)
-  ];
-  const detours = [];
-  for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
-    for (const detourCoordinate of [...new Set(detourCoordinates)]) {
-      const orderedDetourPrefix = firstSegmentAxis === "y" ? [
-        start,
-        { x: escapeCoordinate, y: start.y },
-        { x: escapeCoordinate, y: detourCoordinate },
-        { x: end.x, y: detourCoordinate },
-        end
-      ] : [
-        start,
-        { x: start.x, y: escapeCoordinate },
-        { x: detourCoordinate, y: escapeCoordinate },
-        { x: detourCoordinate, y: end.y },
-        end
-      ];
-      const orderedDetour = [...orderedDetourPrefix, ...orderedPath.slice(3)];
-      const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour;
-      if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour);
-    }
-  }
-  return detours;
-};
-
-// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps.ts
-var EPS3 = 1e-9;
 var shiftSegmentOrth = (pts, segIndex, axis, newCoord, eps = EPS3) => {
   if (segIndex < 0 || segIndex >= pts.length - 1) {
     return null;
@@ -1001,6 +966,121 @@ var pathKey = (pts, decimals = 6) => {
   return key;
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours.ts
+var getSegmentAxis = (start, end) => {
+  if (isVertical(start, end)) return "x";
+  if (isHorizontal(start, end)) return "y";
+  return null;
+};
+var generateEndpointCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle
+}) => {
+  if (path.length < 3 || path.length > 4) return [];
+  const lastSegmentIndex = path.length - 2;
+  if (collidingSegmentIndex !== 0 && collidingSegmentIndex !== lastSegmentIndex) {
+    return [];
+  }
+  const shouldReverse = collidingSegmentIndex === lastSegmentIndex;
+  const orderedPath = shouldReverse ? [...path].reverse() : path;
+  const [start, corner, end] = orderedPath;
+  const firstSegmentAxis = getSegmentAxis(start, corner);
+  const secondSegmentAxis = getSegmentAxis(corner, end);
+  if (!firstSegmentAxis || !secondSegmentAxis) return [];
+  if (firstSegmentAxis === secondSegmentAxis) return [];
+  const escapeCoordinates = [
+    ...midBetweenPointAndRect(secondSegmentAxis, start, obstacle),
+    ...midBetweenPointAndRect(secondSegmentAxis, end, obstacle)
+  ];
+  const detourCoordinates = [
+    ...midBetweenPointAndRect(firstSegmentAxis, start, obstacle),
+    ...midBetweenPointAndRect(firstSegmentAxis, end, obstacle)
+  ];
+  const detours = [];
+  for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
+    for (const detourCoordinate of [...new Set(detourCoordinates)]) {
+      const orderedDetourPrefix = firstSegmentAxis === "y" ? [
+        start,
+        { x: escapeCoordinate, y: start.y },
+        { x: escapeCoordinate, y: detourCoordinate },
+        { x: end.x, y: detourCoordinate },
+        end
+      ] : [
+        start,
+        { x: start.x, y: escapeCoordinate },
+        { x: detourCoordinate, y: escapeCoordinate },
+        { x: detourCoordinate, y: end.y },
+        end
+      ];
+      const orderedDetour = [...orderedDetourPrefix, ...orderedPath.slice(3)];
+      const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour;
+      if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour);
+    }
+  }
+  return detours;
+};
+
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateInternalSegmentCollisionDetours.ts
+var EPS4 = 1e-9;
+var DEFAULT_CLEARANCE = 0.2;
+var isStrictlyBetween = (value, a, b) => value > Math.min(a, b) + EPS4 && value < Math.max(a, b) - EPS4;
+var generateInternalSegmentCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle,
+  clearance = DEFAULT_CLEARANCE
+}) => {
+  if (collidingSegmentIndex <= 0 || collidingSegmentIndex >= path.length - 2) {
+    return [];
+  }
+  const start = path[collidingSegmentIndex];
+  const end = path[collidingSegmentIndex + 1];
+  const detourPoints = [];
+  if (isHorizontal(start, end)) {
+    const movingRight = start.x < end.x;
+    const entryX = movingRight ? obstacle.minX - clearance : obstacle.maxX + clearance;
+    const exitX = movingRight ? obstacle.maxX + clearance : obstacle.minX - clearance;
+    if (!isStrictlyBetween(entryX, start.x, end.x) || !isStrictlyBetween(exitX, start.x, end.x)) {
+      return [];
+    }
+    for (const detourY of [
+      obstacle.minY - clearance,
+      obstacle.maxY + clearance
+    ]) {
+      detourPoints.push([
+        { x: entryX, y: start.y },
+        { x: entryX, y: detourY },
+        { x: exitX, y: detourY },
+        { x: exitX, y: end.y }
+      ]);
+    }
+  } else if (isVertical(start, end)) {
+    const movingUp = start.y < end.y;
+    const entryY = movingUp ? obstacle.minY - clearance : obstacle.maxY + clearance;
+    const exitY = movingUp ? obstacle.maxY + clearance : obstacle.minY - clearance;
+    if (!isStrictlyBetween(entryY, start.y, end.y) || !isStrictlyBetween(exitY, start.y, end.y)) {
+      return [];
+    }
+    for (const detourX of [
+      obstacle.minX - clearance,
+      obstacle.maxX + clearance
+    ]) {
+      detourPoints.push([
+        { x: start.x, y: entryY },
+        { x: detourX, y: entryY },
+        { x: detourX, y: exitY },
+        { x: end.x, y: exitY }
+      ]);
+    }
+  }
+  return detourPoints.map((points) => [
+    ...path.slice(0, collidingSegmentIndex + 1),
+    ...points,
+    ...path.slice(collidingSegmentIndex + 1)
+  ]).filter(hasOnlyNonzeroOrthogonalSegments);
+};
+
 // lib/solvers/GuidelinesSolver/getInputChipBounds.ts
 function getInputChipBounds(chip) {
   const halfWidth = chip.width / 2;
@@ -1013,26 +1093,8 @@ function getInputChipBounds(chip) {
   };
 }
 
-// lib/utils/textBoxBounds.ts
-function getTextBoxBounds(textBox, padding = {}) {
-  return {
-    minX: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
-    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
-    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
-    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0)
-  };
-}
-function boundsOverlap(a, b, eps = 1e-9) {
-  return a.minX < b.maxX - eps && a.maxX > b.minX + eps && a.minY < b.maxY - eps && a.maxY > b.minY + eps;
-}
-function rectIntersectsAnyTextBox(bounds, inputProblem) {
-  for (const textBox of inputProblem.textBoxes ?? []) {
-    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
-  }
-  return false;
-}
-
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+var isTextBoxObstacle = (obstacle) => obstacle.kind === "text_box";
 var chipToRect = (chip) => {
   const b = getInputChipBounds(chip);
   return { kind: "chip", chipId: chip.chipId, ...b };
@@ -1096,13 +1158,11 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     this.obstacles = getObstacleRects(this.inputProblem, {
       textBoxPadding: this.getTextBoxPaddingForConnectionPair()
     });
-    this.textObstacles = new Set(
-      this.obstacles.filter((r) => r.kind === "text_box")
-    );
+    this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle));
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId));
     this.endpointTextObstacles = new Set(
-      endpointChipIds.size > 1 ? this.obstacles.filter(
-        (r) => r.kind === "text_box" && r.textBox.chipId !== void 0 && endpointChipIds.has(r.textBox.chipId)
+      endpointChipIds.size > 1 ? this.obstacles.filter(isTextBoxObstacle).filter(
+        (obstacle) => obstacle.textBox.chipId !== void 0 && endpointChipIds.has(obstacle.textBox.chipId)
       ) : []
     );
     const [pin1, pin2] = this.pins;
@@ -1290,7 +1350,10 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
           path[adjacentEndpointSegIndex + 1]
         )) {
           for (const textObstacle of this.endpointTextObstacles) {
-            excludedRects.add(textObstacle);
+            const textBounds = getTextBoxBounds(textObstacle.textBox);
+            if (!segmentIntersectsRect(segmentStart, segmentEnd, textBounds)) {
+              excludedRects.add(textObstacle);
+            }
           }
         }
         return excludedRects;
@@ -1299,8 +1362,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS12 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS12 && Math.abs(p.y - q.y) < EPS12;
+      const EPS13 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS13 && Math.abs(p.y - q.y) < EPS13;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1373,14 +1436,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       candidates.push(...mids);
     }
     const newStates = [];
-    const addShiftedCandidate = (candidateSegIndex, candidateAxis, coord) => {
-      const newPath = shiftSegmentOrth(
-        path,
-        candidateSegIndex,
-        candidateAxis,
-        coord
-      );
-      if (!newPath) return;
+    const addPathCandidate = (newPath) => {
       const key = pathKey(newPath);
       if (this.visited.has(key)) return;
       this.visited.add(key);
@@ -1393,10 +1449,28 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
         pinBandPenalty: this.getPinBandPenalty(newPath)
       });
     };
+    const addShiftedCandidate = (candidateSegIndex, candidateAxis, coord) => {
+      const newPath = shiftSegmentOrth(
+        path,
+        candidateSegIndex,
+        candidateAxis,
+        coord
+      );
+      if (newPath) addPathCandidate(newPath);
+    };
+    const lastSegIndex = path.length - 2;
+    if (this.connectionPair === void 0 && rect.kind === "text_box" && this.endpointTextObstacles.has(rect) && !collisionRects.has(rect) && originalSegIndex > 0 && originalSegIndex < lastSegIndex) {
+      for (const detour of generateInternalSegmentCollisionDetours({
+        path,
+        collidingSegmentIndex: originalSegIndex,
+        obstacle: rect
+      })) {
+        addPathCandidate(detour);
+      }
+    }
     for (const coord of candidates) {
       addShiftedCandidate(segIndex, axis, coord);
     }
-    const lastSegIndex = path.length - 2;
     const adjacentSegmentIndexes = originalSegIndex === 1 ? [2] : originalSegIndex === lastSegIndex - 1 ? [lastSegIndex - 2] : [];
     for (const adjacentSegIndex of adjacentSegmentIndexes) {
       if (adjacentSegIndex < 0 || adjacentSegIndex >= lastSegIndex) continue;
@@ -1573,13 +1647,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS12 = 1e-6
+  EPS: EPS13 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical5 = Math.abs(start.x - end.x) < EPS12;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS12;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS13;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS13;
   if (!isVertical5 && !isHorizontal4) return;
   const segDir = isVertical5 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -1652,7 +1726,7 @@ var applyJogToTerminalSegment = ({
 };
 
 // lib/solvers/TraceOverlapShiftSolver/TraceOverlapIssueSolver/TraceOverlapIssueSolver.ts
-var EPS4 = 1e-6;
+var EPS5 = 1e-6;
 var TraceOverlapIssueSolver = class extends BaseSolver {
   overlappingTraceSegments;
   interactionKind;
@@ -1741,7 +1815,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
   }
   applyOffsets(offsets) {
     const correctedTraceMap = { ...this.correctedTraceMap };
-    const eq = (a, b) => Math.abs(a - b) < EPS4;
+    const eq = (a, b) => Math.abs(a - b) < EPS5;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, groupIndex) => {
       const offset = offsets[groupIndex];
@@ -1763,9 +1837,9 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           const start = pts[si];
           const end = pts[si + 1];
           if (!start || !end) continue;
-          if (Math.abs(start.x - end.x) < EPS4) {
+          if (Math.abs(start.x - end.x) < EPS5) {
             segmentAxes.set(si, "vertical");
-          } else if (Math.abs(start.y - end.y) < EPS4) {
+          } else if (Math.abs(start.y - end.y) < EPS5) {
             segmentAxes.set(si, "horizontal");
           }
         }
@@ -1780,7 +1854,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS4
+              EPS: EPS5
             });
           } else {
             const start = pts[si];
@@ -1867,7 +1941,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
         max = obstacle.maxY;
       }
       const next = orig + candidateOffset;
-      return orig <= min + EPS4 && next >= max - EPS4 || orig >= max - EPS4 && next <= min + EPS4;
+      return orig <= min + EPS5 && next >= max - EPS5 || orig >= max - EPS5 && next <= min + EPS5;
     });
     const edges = blockingCollisions.map(({ start, isVertical: isVertical5, obstacle }) => {
       if (isVertical5) {
@@ -1904,8 +1978,8 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
       const start = trace.tracePath[traceSegmentIndex];
       const end = trace.tracePath[traceSegmentIndex + 1];
       if (!start || !end) continue;
-      const isVertical5 = Math.abs(start.x - end.x) < EPS4;
-      const isHorizontal4 = Math.abs(start.y - end.y) < EPS4;
+      const isVertical5 = Math.abs(start.x - end.x) < EPS5;
+      const isHorizontal4 = Math.abs(start.y - end.y) < EPS5;
       if (!isVertical5 && !isHorizontal4) continue;
       const shiftedSegment = isVertical5 ? [
         { ...start, x: start.x + offset },
@@ -1997,7 +2071,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS12 = 2e-3;
+    const EPS13 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -2024,7 +2098,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS12) {
+          if (rangeOverlap > EPS13) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2043,7 +2117,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS12) return;
+          if (rangeOverlap < -EPS13) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2066,8 +2140,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS12;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS12;
+            const aVert = Math.abs(a1.x - a2.x) < EPS13;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS13;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2075,11 +2149,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS12;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS12;
+                const bVert = Math.abs(b1.x - b2.x) < EPS13;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS13;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS12) {
+                  if (Math.abs(a1.x - b1.x) < EPS13) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2089,7 +2163,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS12) {
+                  if (Math.abs(a1.y - b1.y) < EPS13) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2145,14 +2219,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS12 = 2e-3;
+    const EPS13 = 2e-3;
     for (const mspPairId in this.correctedTraceMap) {
       const tracePath = this.correctedTraceMap[mspPairId].tracePath;
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal4 = Math.abs(p1.y - p2.y) < EPS12;
-        const isVertical5 = Math.abs(p1.x - p2.x) < EPS12;
+        const isHorizontal4 = Math.abs(p1.y - p2.y) < EPS13;
+        const isVertical5 = Math.abs(p1.x - p2.x) < EPS13;
         if (!isHorizontal4 && !isVertical5) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2166,13 +2240,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS12 = 2e-3;
+    const EPS13 = 2e-3;
     const p0 = i > 0 ? tracePath[i - 1] : null;
     const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null;
-    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS12 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS12 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS12 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS12 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS13 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS13 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS13 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS13 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2299,24 +2373,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS12 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS12;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS12;
+function segmentIntersectsRect2(p1, p2, rect, EPS13 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS13;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS13;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS12 || x > rect.maxX + EPS12) return false;
+    if (x < rect.minX - EPS13 || x > rect.maxX + EPS13) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS12;
+    return overlap > EPS13;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS12 || y > rect.maxY + EPS12) return false;
+    if (y < rect.minY - EPS13 || y > rect.maxY + EPS13) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS12;
+    return overlap > EPS13;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -2713,14 +2787,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS12 = 1e-6;
+    const EPS13 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS12;
-        const isV = Math.abs(a.x - b.x) < EPS12;
+        const isH = Math.abs(a.y - b.y) < EPS13;
+        const isV = Math.abs(a.x - b.x) < EPS13;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -3820,7 +3894,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       paddingBuffer: effectivePadding
       // Use the calculated, larger padding
     });
-    const getPathLength2 = (pts) => {
+    const getPathLength3 = (pts) => {
       let len = 0;
       for (let i = 0; i < pts.length - 1; i++) {
         const dx = pts[i + 1].x - pts[i].x;
@@ -3830,7 +3904,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       return len;
     };
     this.queuedCandidatePaths = candidates.sort(
-      (a, b) => getPathLength2(a) - getPathLength2(b)
+      (a, b) => getPathLength3(a) - getPathLength3(b)
     );
     this.obstacles = getObstacleRects(this.problem);
   }
@@ -5123,9 +5197,9 @@ var moveRailSegments = (trace, segments, coordinate) => {
 };
 
 // lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
-var EPS5 = 1e-6;
+var EPS6 = 1e-6;
 var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
-var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS5 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS5;
+var rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS6 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS6;
 var getTraceCorners = (path) => {
   const corners = [];
   for (let i = 1; i < path.length - 1; i++) {
@@ -5149,11 +5223,11 @@ var getUniquePinCount = (pinIds) => new Set(pinIds).size;
 var isTraceCorner = (a, b, c) => getSegmentOrientation(a, b) !== getSegmentOrientation(b, c);
 var isPointOnSegment = (point, start, end) => {
   if (getSegmentOrientation(start, end) === "horizontal") {
-    return Math.abs(point.y - start.y) <= EPS5 && point.x >= Math.min(start.x, end.x) - EPS5 && point.x <= Math.max(start.x, end.x) + EPS5;
+    return Math.abs(point.y - start.y) <= EPS6 && point.x >= Math.min(start.x, end.x) - EPS6 && point.x <= Math.max(start.x, end.x) + EPS6;
   }
-  return Math.abs(point.x - start.x) <= EPS5 && point.y >= Math.min(start.y, end.y) - EPS5 && point.y <= Math.max(start.y, end.y) + EPS5;
+  return Math.abs(point.x - start.x) <= EPS6 && point.y >= Math.min(start.y, end.y) - EPS6 && point.y <= Math.max(start.y, end.y) + EPS6;
 };
-var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS5 ? "horizontal" : "vertical";
+var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS6 ? "horizontal" : "vertical";
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors.ts
 var getAnchoredTraceIds = (label, traces) => new Set(
@@ -5169,17 +5243,17 @@ var preservesLabelAnchors = (labels, before, after) => labels.every((label) => {
 });
 
 // lib/solvers/Example28Solver/types.ts
-var EPS6 = 1e-9;
+var EPS7 = 1e-9;
 
 // lib/solvers/Example28Solver/segmentRunsAlongRectBoundary.ts
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS6;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS6;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS7;
+  const isHorizontal4 = Math.abs(start.y - end.y) < EPS7;
   if (isVertical5) {
-    return Math.abs(start.x - rect.minX) < EPS6 || Math.abs(start.x - rect.maxX) < EPS6;
+    return Math.abs(start.x - rect.minX) < EPS7 || Math.abs(start.x - rect.maxX) < EPS7;
   }
   if (isHorizontal4) {
-    return Math.abs(start.y - rect.minY) < EPS6 || Math.abs(start.y - rect.maxY) < EPS6;
+    return Math.abs(start.y - rect.minY) < EPS7 || Math.abs(start.y - rect.maxY) < EPS7;
   }
   return false;
 };
@@ -5194,10 +5268,10 @@ var getPathLength = (path) => {
   return length;
 };
 var getDistance2 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS6 || Math.abs(start.y - end.y) < EPS6;
-var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS6 ? "horizontal" : "vertical";
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS7 || Math.abs(start.y - end.y) < EPS7;
+var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS7 ? "horizontal" : "vertical";
 var projectPointToSegment = (point, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS6) {
+  if (Math.abs(start.x - end.x) < EPS7) {
     return {
       x: start.x,
       y: Math.min(
@@ -5206,7 +5280,7 @@ var projectPointToSegment = (point, start, end) => {
       )
     };
   }
-  if (Math.abs(start.y - end.y) < EPS6) {
+  if (Math.abs(start.y - end.y) < EPS7) {
     return {
       x: Math.min(
         Math.max(point.x, Math.min(start.x, end.x)),
@@ -5249,9 +5323,9 @@ var findSegmentContainingPoint = (path, point) => {
 };
 var isPointWithinSegmentPrimaryRange = (point, segment) => {
   if (segment.orientation === "horizontal") {
-    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS6 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS6;
+    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS7 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS7;
   }
-  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS6 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS6;
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS7 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS7;
 };
 var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
   const matchingSegments = getSegments(path).filter(
@@ -5270,27 +5344,27 @@ var projectPointToPath = (point, path) => {
   let bestDistance = Number.POSITIVE_INFINITY;
   for (let i = 0; i < path.length - 1; i++) {
     const projectedPoint = projectPointToSegment(point, path[i], path[i + 1]);
-    const distance4 = getDistance2(point, projectedPoint);
-    if (distance4 < bestDistance) {
+    const distance5 = getDistance2(point, projectedPoint);
+    if (distance5 < bestDistance) {
       bestPoint = projectedPoint;
-      bestDistance = distance4;
+      bestDistance = distance5;
     }
   }
   return bestPoint;
 };
 var segmentsIntersect = (a1, a2, b1, b2) => {
-  const aVertical = Math.abs(a1.x - a2.x) < EPS6;
-  const bVertical = Math.abs(b1.x - b2.x) < EPS6;
-  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS6 && value <= Math.max(p1, p2) + EPS6;
+  const aVertical = Math.abs(a1.x - a2.x) < EPS7;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS7;
+  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS7 && value <= Math.max(p1, p2) + EPS7;
   if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS6) return false;
+    if (Math.abs(a1.x - b1.x) > EPS7) return false;
     const overlap = Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) - Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y));
-    return overlap > EPS6;
+    return overlap > EPS7;
   }
   if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS6) return false;
+    if (Math.abs(a1.y - b1.y) > EPS7) return false;
     const overlap = Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) - Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x));
-    return overlap > EPS6;
+    return overlap > EPS7;
   }
   const verticalA = aVertical ? a1 : b1;
   const verticalB = aVertical ? a2 : b2;
@@ -5652,7 +5726,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
 
 // lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
-var EPS7 = 1e-6;
+var EPS8 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   const intersections = [];
   for (const obstacle of obstacles) {
@@ -5671,17 +5745,17 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   }
   return intersections;
 };
-var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS7 && Math.abs(first.y - second.y) < EPS7;
+var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS8 && Math.abs(first.y - second.y) < EPS8;
 var findPerpendicularPathCrossings = (path, otherPath) => {
   const crossings = [];
   for (let pathSegmentIndex = 1; pathSegmentIndex < path.length - 2; pathSegmentIndex++) {
     const start = path[pathSegmentIndex];
     const end = path[pathSegmentIndex + 1];
-    const isVertical5 = Math.abs(start.x - end.x) < EPS7;
+    const isVertical5 = Math.abs(start.x - end.x) < EPS8;
     for (let otherPathSegmentIndex = 1; otherPathSegmentIndex < otherPath.length - 2; otherPathSegmentIndex++) {
       const otherStart = otherPath[otherPathSegmentIndex];
       const otherEnd = otherPath[otherPathSegmentIndex + 1];
-      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS7;
+      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS8;
       if (isVertical5 === otherIsVertical) continue;
       const intersection = getSegmentIntersection(
         start,
@@ -5701,8 +5775,8 @@ var findPerpendicularPathCrossings = (path, otherPath) => {
 };
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS8 = 1e-6;
-var isVertical3 = (a, b, eps = EPS8) => Math.abs(a.x - b.x) < eps;
+var EPS9 = 1e-6;
+var isVertical3 = (a, b, eps = EPS9) => Math.abs(a.x - b.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -5715,7 +5789,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS8 && Math.abs(p2.y - (y + height)) < EPS8) {
+  if (Math.abs(p2.x - x) < EPS9 && Math.abs(p2.y - (y + height)) < EPS9) {
     c2 = { x: x + width + padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -5727,7 +5801,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS8 && Math.abs(p2.y - (y + height)) < EPS8) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS9 && Math.abs(p2.y - (y + height)) < EPS9) {
     c2 = { x: x - padding, y: y - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -5739,7 +5813,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS8 && Math.abs(p2.y - y) < EPS8) {
+  } else if (Math.abs(p2.x - x) < EPS9 && Math.abs(p2.y - y) < EPS9) {
     c2 = { x: x + width + padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -5751,7 +5825,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS8 && Math.abs(p2.y - y) < EPS8) {
+  } else if (Math.abs(p2.x - (x + width)) < EPS9 && Math.abs(p2.y - y) < EPS9) {
     c2 = { x: x - padding, y: y + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -5779,7 +5853,7 @@ var generatePerpendicularTraceDetours = ({
   const buildDetours = (path, index) => {
     const start = path[index];
     const end = path[index + 1];
-    const movingAxis = Math.abs(start.x - end.x) < EPS8 ? "y" : "x";
+    const movingAxis = Math.abs(start.x - end.x) < EPS9 ? "y" : "x";
     const detourAxis = movingAxis === "x" ? "y" : "x";
     const gate = obstacleStart[movingAxis] + Math.sign(start[movingAxis] - obstacleStart[movingAxis]) * clearance;
     const obstacleRange = [obstacleStart[detourAxis], obstacleEnd[detourAxis]];
@@ -6377,9 +6451,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-var EPS9 = 1e-6;
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS9;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS9;
+var EPS10 = 1e-6;
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS10;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS10;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
@@ -6654,7 +6728,7 @@ var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
     const end = path[i + 1];
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
-      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS6) {
+      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS7) {
         return true;
       }
     }
@@ -6669,13 +6743,13 @@ var getChipBoundaryOverlap = (path, chipObstacles) => {
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
       const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle);
-      if (overlap > EPS6) total += overlap;
+      if (overlap > EPS7) total += overlap;
     }
   }
   return total;
 };
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical5 = Math.abs(start.x - end.x) < EPS6;
+  const isVertical5 = Math.abs(start.x - end.x) < EPS7;
   if (isVertical5) {
     return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
   }
@@ -7087,11 +7161,11 @@ var getLabelHugDistance = (tracePath, obstacleLabel) => {
     obstacleLabel.width,
     obstacleLabel.height
   );
-  let distance4 = 0;
+  let distance5 = 0;
   for (const point of tracePath) {
-    distance4 += getPointDistanceFromRect(point, bounds);
+    distance5 += getPointDistanceFromRect(point, bounds);
   }
-  return distance4;
+  return distance5;
 };
 var getPointDistanceFromRect = (point, rect) => {
   const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX);
@@ -7368,16 +7442,16 @@ var Example28Solver = class extends BaseSolver {
     const outward = dir(label.orientation);
     if (outward.x === 0 && outward.y === 0) return null;
     for (let step = 1; step <= LABEL_MAX_OUTWARD_STEPS; step++) {
-      const distance4 = step * LABEL_OUTWARD_STEP;
+      const distance5 = step * LABEL_OUTWARD_STEP;
       const candidate = {
         ...label,
         anchorPoint: {
-          x: label.anchorPoint.x + outward.x * distance4,
-          y: label.anchorPoint.y + outward.y * distance4
+          x: label.anchorPoint.x + outward.x * distance5,
+          y: label.anchorPoint.y + outward.y * distance5
         },
         center: {
-          x: label.center.x + outward.x * distance4,
-          y: label.center.y + outward.y * distance4
+          x: label.center.x + outward.x * distance5,
+          y: label.center.y + outward.y * distance5
         }
       };
       const candidateWithClearance = {
@@ -7439,16 +7513,16 @@ var createPortOnlyLabelConnectorTrace = ({
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS10 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS10;
+var EPS11 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS11;
 var CANDIDATE_SELECTED_COLOR2 = "blue";
 var CANDIDATE_REJECTED_COLOR2 = "red";
 
 // lib/solvers/AvailableNetOrientationSolver/geometry.ts
 var isYOrientation = (orientation) => orientation === "y+" || orientation === "y-";
 var isXOrientation = (orientation) => orientation === "x+" || orientation === "x-";
-var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS10 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS10;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS10;
+var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS11 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS11;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS11;
 var traceCrossesBoundsInterior = (bounds, traceMap) => {
   for (const trace of Object.values(traceMap)) {
     const points = trace.tracePath;
@@ -7471,7 +7545,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS10 || p1.x >= interiorBounds.maxX - EPS10) {
+    if (p1.x <= interiorBounds.minX + EPS11 || p1.x >= interiorBounds.maxX - EPS11) {
       return false;
     }
     return rangesOverlap(
@@ -7482,7 +7556,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS10 || p1.y >= interiorBounds.maxY - EPS10) {
+    if (p1.y <= interiorBounds.minY + EPS11 || p1.y >= interiorBounds.maxY - EPS11) {
       return false;
     }
     return rangesOverlap(
@@ -7538,8 +7612,8 @@ var simplifyOrthogonalPath = (path) => {
   return simplified;
 };
 var pointsEqual2 = (a, b) => sameX2(a, b) && sameY2(a, b);
-var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS10;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS10;
+var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS11;
+var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS11;
 var getMaxSearchDistance = (inputProblem) => {
   const maxChipWidth = Math.max(
     ...inputProblem.chips.map((chip) => chip.width),
@@ -7794,11 +7868,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (trace.globalConnNetId !== label.globalConnNetId) return false;
       const path = trace.tracePath;
       return path.some((point, pointIndex) => {
-        if (Math.abs(point.x - label.anchorPoint.x) > EPS10 || Math.abs(point.y - label.anchorPoint.y) > EPS10) {
+        if (Math.abs(point.x - label.anchorPoint.x) > EPS11 || Math.abs(point.y - label.anchorPoint.y) > EPS11) {
           return false;
         }
         return [path[pointIndex - 1], path[pointIndex + 1]].some(
-          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS10 && (neighbor.y - point.y) * direction.y > EPS10
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS11 && (neighbor.y - point.y) * direction.y > EPS11
         );
       });
     });
@@ -7877,7 +7951,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     );
     const maxSearchDistance = this.getSearchDistanceLimit(label, orientation);
     const maxOutwardDistance = outwardDirection.x === 0 && outwardDirection.y === 0 ? 0 : this.maxSearchDistance;
-    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS10; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS11; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
@@ -7951,10 +8025,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       phase = "shift",
       stopOnTraceCollision = true
     } = params;
-    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS10; distance4 += LABEL_SEARCH_STEP) {
+    for (let distance5 = LABEL_SEARCH_STEP; distance5 <= maxSearchDistance + EPS11; distance5 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
-        x: baseAnchor.x + direction.x * distance4,
-        y: baseAnchor.y + direction.y * distance4
+        x: baseAnchor.x + direction.x * distance5,
+        y: baseAnchor.y + direction.y * distance5
       };
       const candidate = this.createCandidate(label, anchorPoint, orientation);
       const result = this.evaluateCandidate(
@@ -7962,7 +8036,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         label,
         labelIndex,
         phase,
-        distance4,
+        distance5,
         outwardDistance
       );
       this.currentCandidateResults.push(result);
@@ -7974,11 +8048,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  evaluateCandidate(candidate, label, labelIndex, phase, distance4, outwardDistance) {
+  evaluateCandidate(candidate, label, labelIndex, phase, distance5, outwardDistance) {
     return {
       ...candidate,
       phase,
-      distance: distance4,
+      distance: distance5,
       outwardDistance,
       selected: false,
       status: this.getCandidateStatus({
@@ -8188,9 +8262,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS10 || anchorPoint.x > chipBounds.maxX + EPS10;
+        return anchorPoint.x < chipBounds.minX - EPS11 || anchorPoint.x > chipBounds.maxX + EPS11;
       }
-      return anchorPoint.y < chipBounds.minY - EPS10 || anchorPoint.y > chipBounds.maxY + EPS10;
+      return anchorPoint.y < chipBounds.minY - EPS11 || anchorPoint.y > chipBounds.maxY + EPS11;
     });
   }
   getBoundsStatus(candidateBoundsCheck) {
@@ -8264,8 +8338,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   sharesChipBoundary(bounds) {
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const chipBounds = chip.bounds;
-      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS10 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS10;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS10 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS10;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS11 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS11;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS11 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS11;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -8313,13 +8387,13 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      if (point.x < bounds.minX - EPS10 || point.x > bounds.maxX + EPS10 || point.y < bounds.minY - EPS10 || point.y > bounds.maxY + EPS10) {
+      if (point.x < bounds.minX - EPS11 || point.x > bounds.maxX + EPS11 || point.y < bounds.minY - EPS11 || point.y > bounds.maxY + EPS11) {
         continue;
       }
-      for (const [side, distance4] of getSideDistances(point, bounds)) {
-        if (distance4 < nearestDistance) {
+      for (const [side, distance5] of getSideDistances(point, bounds)) {
+        if (distance5 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance4;
+          nearestDistance = distance5;
         }
       }
     }
@@ -8330,8 +8404,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestDistanceSq = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      const dx = point.x < bounds.minX - EPS10 ? bounds.minX - point.x : point.x > bounds.maxX + EPS10 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS10 ? bounds.minY - point.y : point.y > bounds.maxY + EPS10 ? point.y - bounds.maxY : 0;
+      const dx = point.x < bounds.minX - EPS11 ? bounds.minX - point.x : point.x > bounds.maxX + EPS11 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS11 ? bounds.minY - point.y : point.y > bounds.maxY + EPS11 ? point.y - bounds.maxY : 0;
       if (dx === 0 && dy === 0) continue;
       const distanceSq = dx ** 2 + dy ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -8348,10 +8422,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestSide = null;
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
-      for (const [side, distance4] of getSideDistances(point, chip.bounds)) {
-        if (distance4 < nearestDistance) {
+      for (const [side, distance5] of getSideDistances(point, chip.bounds)) {
+        if (distance5 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance4;
+          nearestDistance = distance5;
         }
       }
     }
@@ -8615,8 +8689,8 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
         if (seenCornerKeys.has(key)) continue;
         seenCornerKeys.add(key);
         const pinAligned = pins.some((pin) => {
-          if (isVertical5) return Math.abs(pin.x - anchorPoint.x) < EPS5;
-          return Math.abs(pin.y - anchorPoint.y) < EPS5;
+          if (isVertical5) return Math.abs(pin.x - anchorPoint.x) < EPS6;
+          return Math.abs(pin.y - anchorPoint.y) < EPS6;
         });
         if (!pinAligned) continue;
         candidates.push({
@@ -8709,11 +8783,11 @@ var getOrientationConstraint = (inputProblem, label) => {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS11 = 1e-6;
+var EPS12 = 1e-6;
 var TRACE_BOUNDARY_TOLERANCE2 = 1e-6;
 var getLabelBounds = (label) => getRectBounds(label.center, label.width, label.height);
-var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS11 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS11;
-var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS11 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS11;
+var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS12;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS12 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS12;
 var traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -8752,17 +8826,17 @@ var getTraceLength = (trace) => {
   }
   return length;
 };
-var getPointAtTraceDistance = (trace, distance4) => {
+var getPointAtTraceDistance = (trace, distance5) => {
   let pathDistance = 0;
   for (let i = 0; i < trace.tracePath.length - 1; i++) {
     const start = trace.tracePath[i];
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance4 <= nextDistance + EPS11) {
+    if (distance5 <= nextDistance + EPS12) {
       const offset = Math.max(
         0,
-        Math.min(segmentLength, distance4 - pathDistance)
+        Math.min(segmentLength, distance5 - pathDistance)
       );
       const direction = getSegmentDirection(start, end);
       return {
@@ -8798,7 +8872,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical4(start, end)) {
-    if (start.x <= interior.minX + EPS11 || start.x >= interior.maxX - EPS11) {
+    if (start.x <= interior.minX + EPS12 || start.x >= interior.maxX - EPS12) {
       return false;
     }
     return rangesOverlap2(
@@ -8809,7 +8883,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal3(start, end)) {
-    if (start.y <= interior.minY + EPS11 || start.y >= interior.maxY - EPS11) {
+    if (start.y <= interior.minY + EPS12 || start.y >= interior.maxY - EPS12) {
       return false;
     }
     return rangesOverlap2(
@@ -8823,10 +8897,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal3(start, end)) {
-    return Math.abs(point.y - start.y) <= EPS11 && point.x >= Math.min(start.x, end.x) - EPS11 && point.x <= Math.max(start.x, end.x) + EPS11;
+    return Math.abs(point.y - start.y) <= EPS12 && point.x >= Math.min(start.x, end.x) - EPS12 && point.x <= Math.max(start.x, end.x) + EPS12;
   }
   if (isVertical4(start, end)) {
-    return Math.abs(point.x - start.x) <= EPS11 && point.y >= Math.min(start.y, end.y) - EPS11 && point.y <= Math.max(start.y, end.y) + EPS11;
+    return Math.abs(point.x - start.x) <= EPS12 && point.y >= Math.min(start.y, end.y) - EPS12 && point.y <= Math.max(start.y, end.y) + EPS12;
   }
   return false;
 };
@@ -8834,9 +8908,9 @@ var getSegmentDirection = (start, end) => ({
   x: isVertical4(start, end) ? 0 : Math.sign(end.x - start.x),
   y: isHorizontal3(start, end) ? 0 : Math.sign(end.y - start.y)
 });
-var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS11;
-var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS11;
-var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS11;
+var isHorizontal3 = (start, end) => Math.abs(start.y - end.y) <= EPS12;
+var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS12;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS12;
 var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
@@ -8887,13 +8961,13 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   const distances = /* @__PURE__ */ new Set();
   const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP);
   for (let i = 0; i <= maxSteps; i++) {
-    const distance4 = Math.min(traceLength, i * CANDIDATE_STEP);
-    distances.add(roundDistance(distance4));
+    const distance5 = Math.min(traceLength, i * CANDIDATE_STEP);
+    distances.add(roundDistance(distance5));
   }
-  for (const distance4 of vertexDistances) {
-    distances.add(roundDistance(distance4));
+  for (const distance5 of vertexDistances) {
+    distances.add(roundDistance(distance5));
   }
-  return [...distances].filter((distance4) => distance4 >= -EPS11 && distance4 <= traceLength + EPS11).sort((a, b) => a - b);
+  return [...distances].filter((distance5) => distance5 >= -EPS12 && distance5 <= traceLength + EPS12).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -8982,13 +9056,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS11) {
+  if (value > max + EPS12) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS11) {
+  if (value < min - EPS12) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -8999,7 +9073,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS11, span / 2);
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS12, span / 2);
 var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
 var getFlippedOrientation = (orientation) => {
   switch (orientation) {
@@ -9071,8 +9145,8 @@ var getNetLabelHeight = (inputProblem, label) => {
     (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
   )?.netLabelHeight;
 };
-var roundDistance = (distance4) => Number(distance4.toFixed(6));
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS11 && Math.abs(point.y - label.anchorPoint.y) <= EPS11 && orientation === label.orientation;
+var roundDistance = (distance5) => Number(distance5.toFixed(6));
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS12 && Math.abs(point.y - label.anchorPoint.y) <= EPS12 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR4 = "blue";
@@ -10037,6 +10111,457 @@ ${c.status}`
   }
 };
 
+// lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts
+import { distance as distance4, doSegmentsIntersect as doSegmentsIntersect3 } from "@tscircuit/math-utils";
+var ROUTE_CLEARANCE = 0.2;
+var COORDINATE_TOLERANCE = 1e-9;
+var GROUND_NET_ID = "GND";
+var pointsAreEqual = (firstPoint, secondPoint) => {
+  return Math.abs(firstPoint.x - secondPoint.x) <= COORDINATE_TOLERANCE && Math.abs(firstPoint.y - secondPoint.y) <= COORDINATE_TOLERANCE;
+};
+var removeConsecutiveDuplicatePoints = (path) => {
+  const filteredPath = [];
+  for (const point of path) {
+    const previousPoint = filteredPath.at(-1);
+    if (!previousPoint || !pointsAreEqual(previousPoint, point)) {
+      filteredPath.push(point);
+    }
+  }
+  return filteredPath;
+};
+var getPathLength2 = (path) => {
+  let pathLength = 0;
+  for (let pointIndex = 0; pointIndex < path.length - 1; pointIndex++) {
+    const startPoint = path[pointIndex];
+    const endPoint = path[pointIndex + 1];
+    pathLength += Math.abs(endPoint.x - startPoint.x) + Math.abs(endPoint.y - startPoint.y);
+  }
+  return pathLength;
+};
+var getEscapePoint = ({
+  pin,
+  facingDirection
+}) => {
+  const escapePoint = { x: pin.x, y: pin.y };
+  if (facingDirection === "x+") {
+    escapePoint.x += ROUTE_CLEARANCE;
+  }
+  if (facingDirection === "x-") {
+    escapePoint.x -= ROUTE_CLEARANCE;
+  }
+  if (facingDirection === "y+") {
+    escapePoint.y += ROUTE_CLEARANCE;
+  }
+  if (facingDirection === "y-") {
+    escapePoint.y -= ROUTE_CLEARANCE;
+  }
+  return escapePoint;
+};
+var getOuterBounds = (obstacles) => {
+  return {
+    minX: Math.min(...obstacles.map((obstacle) => obstacle.minX)),
+    minY: Math.min(...obstacles.map((obstacle) => obstacle.minY)),
+    maxX: Math.max(...obstacles.map((obstacle) => obstacle.maxX)),
+    maxY: Math.max(...obstacles.map((obstacle) => obstacle.maxY))
+  };
+};
+var getPerimeterCandidates = ({
+  connectionPair,
+  obstacles
+}) => {
+  const [firstPin, secondPin] = connectionPair.pins;
+  const firstEscapePoint = getEscapePoint({
+    pin: firstPin,
+    facingDirection: firstPin._facingDirection
+  });
+  const secondEscapePoint = getEscapePoint({
+    pin: secondPin,
+    facingDirection: secondPin._facingDirection
+  });
+  const outerBounds = getOuterBounds(obstacles);
+  const horizontalChannels = [
+    outerBounds.minY - ROUTE_CLEARANCE,
+    outerBounds.maxY + ROUTE_CLEARANCE
+  ];
+  const verticalChannels = [
+    outerBounds.minX - ROUTE_CLEARANCE,
+    outerBounds.maxX + ROUTE_CLEARANCE
+  ];
+  const candidates = [];
+  for (const channelY of horizontalChannels) {
+    candidates.push(
+      removeConsecutiveDuplicatePoints([
+        firstPin,
+        firstEscapePoint,
+        { x: firstEscapePoint.x, y: channelY },
+        { x: secondEscapePoint.x, y: channelY },
+        secondEscapePoint,
+        secondPin
+      ])
+    );
+  }
+  for (const channelX of verticalChannels) {
+    candidates.push(
+      removeConsecutiveDuplicatePoints([
+        firstPin,
+        firstEscapePoint,
+        { x: channelX, y: firstEscapePoint.y },
+        { x: channelX, y: secondEscapePoint.y },
+        secondEscapePoint,
+        secondPin
+      ])
+    );
+  }
+  return candidates.sort(
+    (firstPath, secondPath) => getPathLength2(firstPath) - getPathLength2(secondPath)
+  );
+};
+var getSegmentMidpoint = (startPoint, endPoint) => {
+  return {
+    x: (startPoint.x + endPoint.x) / 2,
+    y: (startPoint.y + endPoint.y) / 2
+  };
+};
+var getJunctionPoints = (sameNetTraces) => {
+  const junctionPoints = [];
+  for (const trace of sameNetTraces) {
+    for (let pointIndex = 0; pointIndex < trace.tracePath.length - 1; pointIndex++) {
+      const startPoint = trace.tracePath[pointIndex];
+      const endPoint = trace.tracePath[pointIndex + 1];
+      junctionPoints.push(startPoint);
+      junctionPoints.push(getSegmentMidpoint(startPoint, endPoint));
+    }
+    const lastPoint = trace.tracePath.at(-1);
+    if (lastPoint) {
+      junctionPoints.push(lastPoint);
+    }
+  }
+  return junctionPoints;
+};
+var getUnconnectedPins = ({
+  connectionPair,
+  sameNetTraces
+}) => {
+  const connectedPinIds = new Set(
+    sameNetTraces.flatMap((trace) => trace.pinIds)
+  );
+  return connectionPair.pins.filter((pin) => !connectedPinIds.has(pin.pinId));
+};
+var getJunctionCandidates = ({
+  connectionPair,
+  sameNetTraces,
+  obstacles,
+  maxConnectionDistance
+}) => {
+  const outerBounds = getOuterBounds(obstacles);
+  const horizontalChannels = [
+    outerBounds.minY - ROUTE_CLEARANCE,
+    outerBounds.maxY + ROUTE_CLEARANCE
+  ];
+  const verticalChannels = [
+    outerBounds.minX - ROUTE_CLEARANCE,
+    outerBounds.maxX + ROUTE_CLEARANCE
+  ];
+  const candidates = [];
+  const junctionPoints = getJunctionPoints(sameNetTraces);
+  const unconnectedPins = getUnconnectedPins({
+    connectionPair,
+    sameNetTraces
+  });
+  for (const pin of unconnectedPins) {
+    const escapePoint = getEscapePoint({
+      pin,
+      facingDirection: pin._facingDirection
+    });
+    for (const junctionPoint of junctionPoints) {
+      if (distance4(pin, junctionPoint) > maxConnectionDistance) {
+        continue;
+      }
+      candidates.push(
+        removeConsecutiveDuplicatePoints([
+          pin,
+          escapePoint,
+          { x: escapePoint.x, y: junctionPoint.y },
+          junctionPoint
+        ])
+      );
+      candidates.push(
+        removeConsecutiveDuplicatePoints([
+          pin,
+          escapePoint,
+          { x: junctionPoint.x, y: escapePoint.y },
+          junctionPoint
+        ])
+      );
+      for (const channelY of horizontalChannels) {
+        candidates.push(
+          removeConsecutiveDuplicatePoints([
+            pin,
+            escapePoint,
+            { x: escapePoint.x, y: channelY },
+            { x: junctionPoint.x, y: channelY },
+            junctionPoint
+          ])
+        );
+      }
+      for (const channelX of verticalChannels) {
+        candidates.push(
+          removeConsecutiveDuplicatePoints([
+            pin,
+            escapePoint,
+            { x: channelX, y: escapePoint.y },
+            { x: channelX, y: junctionPoint.y },
+            junctionPoint
+          ])
+        );
+      }
+    }
+  }
+  return candidates.sort(
+    (firstPath, secondPath) => getPathLength2(firstPath) - getPathLength2(secondPath)
+  );
+};
+var pathCollidesWithObstacles = ({
+  path,
+  obstacles,
+  connectionPair,
+  rejectComponentBoundaryTravel
+}) => {
+  const firstPathPoint = path[0];
+  const lastPathPoint = path.at(-1);
+  const firstPathPin = connectionPair.pins.find(
+    (pin) => pointsAreEqual(pin, firstPathPoint)
+  );
+  const lastPathPin = connectionPair.pins.find(
+    (pin) => pointsAreEqual(pin, lastPathPoint)
+  );
+  const pathConnectsPairPins = firstPathPin !== void 0 && lastPathPin !== void 0;
+  const firstChipObstacle = obstacles.find(
+    (obstacle) => obstacle.kind === "chip" && obstacle.chipId === firstPathPin?.chipId
+  );
+  const secondChipObstacle = obstacles.find(
+    (obstacle) => obstacle.kind === "chip" && obstacle.chipId === lastPathPin?.chipId
+  );
+  if (rejectComponentBoundaryTravel && firstChipObstacle && segmentOverlapsRectBoundary(path[0], path[1], firstChipObstacle)) {
+    return true;
+  }
+  if (rejectComponentBoundaryTravel && secondChipObstacle && segmentOverlapsRectBoundary(
+    path[path.length - 2],
+    path[path.length - 1],
+    secondChipObstacle
+  )) {
+    return true;
+  }
+  const collision = findFirstCollision(path, obstacles, {
+    excludeRectsForSegment: (segmentIndex) => {
+      const excludedObstacles = /* @__PURE__ */ new Set();
+      if (segmentIndex === 0 && firstChipObstacle) {
+        excludedObstacles.add(firstChipObstacle);
+      }
+      if (pathConnectsPairPins && segmentIndex === path.length - 2 && secondChipObstacle) {
+        excludedObstacles.add(secondChipObstacle);
+      }
+      return excludedObstacles;
+    }
+  });
+  return collision !== null;
+};
+var hasParallelFailedConnection = ({
+  connectionPair,
+  failedConnectionPairs
+}) => {
+  const connectionChipIds = new Set(
+    connectionPair.pins.map((pin) => pin.chipId)
+  );
+  return failedConnectionPairs.some((otherConnectionPair) => {
+    if (otherConnectionPair.mspPairId === connectionPair.mspPairId) {
+      return false;
+    }
+    return otherConnectionPair.pins.every(
+      (pin) => connectionChipIds.has(pin.chipId)
+    );
+  });
+};
+var segmentsOverlapBeyondEndpoint = ({
+  firstStart,
+  firstEnd,
+  secondStart,
+  secondEnd
+}) => {
+  if (isHorizontal(firstStart, firstEnd) && isHorizontal(secondStart, secondEnd)) {
+    const overlapLength = Math.min(
+      Math.max(firstStart.x, firstEnd.x),
+      Math.max(secondStart.x, secondEnd.x)
+    ) - Math.max(
+      Math.min(firstStart.x, firstEnd.x),
+      Math.min(secondStart.x, secondEnd.x)
+    );
+    return overlapLength > COORDINATE_TOLERANCE;
+  }
+  if (isVertical(firstStart, firstEnd) && isVertical(secondStart, secondEnd)) {
+    const overlapLength = Math.min(
+      Math.max(firstStart.y, firstEnd.y),
+      Math.max(secondStart.y, secondEnd.y)
+    ) - Math.max(
+      Math.min(firstStart.y, firstEnd.y),
+      Math.min(secondStart.y, secondEnd.y)
+    );
+    return overlapLength > COORDINATE_TOLERANCE;
+  }
+  return false;
+};
+var getAllowedJunctionPoints = ({
+  connectionPair,
+  existingTrace
+}) => {
+  const existingPinIds = new Set(existingTrace.pinIds);
+  return connectionPair.pins.filter((pin) => existingPinIds.has(pin.pinId));
+};
+var pathCrossesExistingTraces = ({
+  path,
+  connectionPair,
+  existingTraces
+}) => {
+  for (const existingTrace of existingTraces) {
+    if (existingTrace.globalConnNetId === connectionPair.globalConnNetId) {
+      continue;
+    }
+    const allowedJunctionPoints = getAllowedJunctionPoints({
+      connectionPair,
+      existingTrace
+    });
+    for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+      const pathStart = path[pathIndex];
+      const pathEnd = path[pathIndex + 1];
+      for (let traceIndex = 0; traceIndex < existingTrace.tracePath.length - 1; traceIndex++) {
+        const traceStart = existingTrace.tracePath[traceIndex];
+        const traceEnd = existingTrace.tracePath[traceIndex + 1];
+        if (!doSegmentsIntersect3(pathStart, pathEnd, traceStart, traceEnd)) {
+          continue;
+        }
+        const intersectionIsAllowedJunction = allowedJunctionPoints.some(
+          (junctionPoint) => (pointsAreEqual(pathStart, junctionPoint) || pointsAreEqual(pathEnd, junctionPoint)) && (pointsAreEqual(traceStart, junctionPoint) || pointsAreEqual(traceEnd, junctionPoint))
+        );
+        if (intersectionIsAllowedJunction && !segmentsOverlapBeyondEndpoint({
+          firstStart: pathStart,
+          firstEnd: pathEnd,
+          secondStart: traceStart,
+          secondEnd: traceEnd
+        })) {
+          continue;
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var UnroutedTraceRecoverySolver = class extends BaseSolver {
+  constructor(params) {
+    super();
+    this.params = params;
+    this.inputProblem = params.inputProblem;
+    this.alreadySolvedTraces = params.alreadySolvedTraces;
+    this.failedConnectionPairs = params.failedConnectionPairs;
+    this.queuedConnectionPairs = [...params.failedConnectionPairs];
+    this.maxConnectionDistance = this.inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem
+    );
+    this.groundGlobalConnNetId = netConnMap.getNetConnectedToId(GROUND_NET_ID) ?? void 0;
+  }
+  params;
+  inputProblem;
+  alreadySolvedTraces;
+  failedConnectionPairs;
+  queuedConnectionPairs;
+  maxConnectionDistance;
+  groundGlobalConnNetId;
+  solvedUnroutedTraces = [];
+  getConstructorParams() {
+    return this.params;
+  }
+  _step() {
+    const connectionPair = this.queuedConnectionPairs.shift();
+    if (!connectionPair) {
+      this.solved = true;
+      return;
+    }
+    if (connectionPair.globalConnNetId === this.groundGlobalConnNetId) {
+      return;
+    }
+    if (distance4(connectionPair.pins[0], connectionPair.pins[1]) > this.maxConnectionDistance) {
+      return;
+    }
+    const obstacles = getObstacleRects(this.inputProblem);
+    const existingTraces = [
+      ...this.alreadySolvedTraces,
+      ...this.solvedUnroutedTraces
+    ];
+    const sameNetTraces = existingTraces.filter(
+      (trace) => trace.globalConnNetId === connectionPair.globalConnNetId
+    );
+    const junctionCandidates = getJunctionCandidates({
+      connectionPair,
+      sameNetTraces,
+      obstacles,
+      maxConnectionDistance: this.maxConnectionDistance
+    });
+    const perimeterCandidates = getPerimeterCandidates({
+      connectionPair,
+      obstacles
+    });
+    const candidates = [...junctionCandidates, ...perimeterCandidates];
+    const rejectComponentBoundaryTravel = hasParallelFailedConnection({
+      connectionPair,
+      failedConnectionPairs: this.failedConnectionPairs
+    });
+    for (const tracePath of candidates) {
+      if (pathCollidesWithObstacles({
+        path: tracePath,
+        obstacles,
+        connectionPair,
+        rejectComponentBoundaryTravel
+      })) {
+        continue;
+      }
+      if (pathCrossesExistingTraces({
+        path: tracePath,
+        connectionPair,
+        existingTraces
+      })) {
+        continue;
+      }
+      this.solvedUnroutedTraces.push({
+        ...connectionPair,
+        tracePath,
+        mspConnectionPairIds: [connectionPair.mspPairId],
+        pinIds: connectionPair.pins.map((pin) => pin.pinId)
+      });
+      return;
+    }
+  }
+  getOutput() {
+    return {
+      newTraces: this.solvedUnroutedTraces,
+      allTracesMerged: [
+        ...this.alreadySolvedTraces,
+        ...this.solvedUnroutedTraces
+      ]
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem);
+    for (const trace of this.solvedUnroutedTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "blue"
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -10052,6 +10577,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver;
   longDistancePairSolver;
+  unroutedTraceRecoverySolver;
   traceOverlapShiftSolver;
   netLabelPlacementSolver;
   labelMergingSolver;
@@ -10122,13 +10648,24 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         }
       }
     ),
+    definePipelineStep(
+      "unroutedTraceRecoverySolver",
+      UnroutedTraceRecoverySolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          failedConnectionPairs: instance.schematicTraceLinesSolver.failedConnectionPairs,
+          alreadySolvedTraces: instance.longDistancePairSolver.getOutput().allTracesMerged
+        }
+      ]
+    ),
     definePipelineStep(
       "traceOverlapShiftSolver",
       TraceOverlapShiftSolver,
       () => [
         {
           inputProblem: this.inputProblem,
-          inputTracePaths: this.longDistancePairSolver?.getOutput().allTracesMerged,
+          inputTracePaths: this.unroutedTraceRecoverySolver?.getOutput().allTracesMerged,
           globalConnMap: this.mspConnectionPairSolver.globalConnMap
         }
       ],
@@ -10144,7 +10681,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: this.inputProblem,
           inputTraceMap: this.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-            this.longDistancePairSolver.getOutput().allTracesMerged.map(
+            this.unroutedTraceRecoverySolver.getOutput().allTracesMerged.map(
               (p) => [p.mspPairId, p]
             )
           )
@@ -10160,7 +10697,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       TraceLabelOverlapAvoidanceSolver,
       (instance) => {
         const traceMap = instance.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-          instance.longDistancePairSolver.getOutput().allTracesMerged.map((p) => [p.mspPairId, p])
+          instance.unroutedTraceRecoverySolver.getOutput().allTracesMerged.map((p) => [p.mspPairId, p])
         );
         const traces = Object.values(traceMap);
         const netLabelPlacements = instance.netLabelPlacementSolver.netLabelPlacements;