@tscircuit/schematic-trace-solver 0.0.106 → 0.0.108

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS11 = 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) < -EPS11) 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) < -EPS11) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS13) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS11 || Math.abs(p1.y - p2.y) < EPS11) {
+  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 };
@@ -630,6 +630,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 +894,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 +904,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 +965,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 +1092,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 +1157,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 +1349,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 +1361,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS11 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS11 && Math.abs(p.y - q.y) < EPS11;
+      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 +1435,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 +1448,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 +1646,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS11 = 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) < EPS11;
-  const isHorizontal4 = Math.abs(start.y - end.y) < EPS11;
+  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 +1725,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 +1814,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 +1836,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 +1853,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS4
+              EPS: EPS5
             });
           } else {
             const start = pts[si];
@@ -1867,7 +1940,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 +1977,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 +2070,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS11 = 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 +2097,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS11) {
+          if (rangeOverlap > EPS13) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2043,7 +2116,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS11) return;
+          if (rangeOverlap < -EPS13) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2066,8 +2139,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) < EPS11;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS11;
+            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 +2148,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) < EPS11;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS11;
+                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) < EPS11) {
+                  if (Math.abs(a1.x - b1.x) < EPS13) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2089,7 +2162,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS11) {
+                  if (Math.abs(a1.y - b1.y) < EPS13) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2145,14 +2218,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS11 = 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) < EPS11;
-        const isVertical5 = Math.abs(p1.x - p2.x) < EPS11;
+        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 +2239,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS11 = 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) < EPS11 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS11 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS11 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS11 : 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 +2372,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS11 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS11;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS11;
+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 - EPS11 || x > rect.maxX + EPS11) 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 > EPS11;
+    return overlap > EPS13;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS11 || y > rect.maxY + EPS11) 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 > EPS11;
+    return overlap > EPS13;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -2713,14 +2786,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS11 = 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) < EPS11;
-        const isV = Math.abs(a.x - b.x) < EPS11;
+        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(
@@ -5123,9 +5196,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 +5222,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 +5242,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 +5267,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 +5279,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 +5322,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(
@@ -5279,18 +5352,18 @@ var projectPointToPath = (point, path) => {
   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,6 +5725,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
 
 // lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
+var EPS8 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   const intersections = [];
   for (const obstacle of obstacles) {
@@ -5670,10 +5744,38 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   }
   return intersections;
 };
+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) < 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) < EPS8;
+      if (isVertical5 === otherIsVertical) continue;
+      const intersection = getSegmentIntersection(
+        start,
+        end,
+        otherStart,
+        otherEnd
+      );
+      if (!intersection || [start, end, otherStart, otherEnd].some(
+        (point) => isSamePoint(point, intersection)
+      )) {
+        continue;
+      }
+      crossings.push({ pathSegmentIndex, otherPathSegmentIndex });
+    }
+  }
+  return crossings;
+};
 
 // lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
-var EPS7 = 1e-6;
-var isVertical3 = (a, b, eps = EPS7) => 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,
@@ -5686,7 +5788,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x) < EPS7 && Math.abs(p2.y - (y + height)) < EPS7) {
+  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 };
@@ -5698,7 +5800,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS7 && Math.abs(p2.y - (y + height)) < EPS7) {
+  } 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 };
@@ -5710,7 +5812,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x) < EPS7 && Math.abs(p2.y - y) < EPS7) {
+  } 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 };
@@ -5722,7 +5824,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x + width)) < EPS7 && Math.abs(p2.y - y) < EPS7) {
+  } 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 };
@@ -5739,6 +5841,48 @@ var generateLShapeRerouteCandidates = ({
   }
   return [[i1_padded, c2, i2_padded]];
 };
+var generatePerpendicularTraceDetours = ({
+  trace,
+  segmentIndex,
+  obstacleStart,
+  obstacleEnd,
+  chipBounds,
+  clearance
+}) => {
+  const buildDetours = (path, index) => {
+    const start = path[index];
+    const end = path[index + 1];
+    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]];
+    const lowBound = detourAxis === "x" ? "minX" : "minY";
+    const highBound = detourAxis === "x" ? "maxX" : "maxY";
+    const detourCoordinates = [
+      Math.min(...obstacleRange) - clearance,
+      Math.max(...obstacleRange) + clearance,
+      ...chipBounds.flatMap((bounds) => [
+        bounds[lowBound] - clearance,
+        bounds[highBound] + clearance
+      ])
+    ];
+    return [...new Set(detourCoordinates)].map(
+      (detour) => simplifyPath([
+        ...path.slice(0, index + 1),
+        { ...start, [movingAxis]: gate },
+        { ...start, [movingAxis]: gate, [detourAxis]: detour },
+        { ...end, [detourAxis]: detour },
+        ...path.slice(index + 2)
+      ])
+    );
+  };
+  const reversedPath = [...trace.tracePath].reverse();
+  const reversedIndex = trace.tracePath.length - 2 - segmentIndex;
+  return [
+    ...buildDetours(trace.tracePath, segmentIndex),
+    ...buildDetours(reversedPath, reversedIndex).map((path) => path.reverse())
+  ].map((path) => ({ traceId: trace.mspPairId, path }));
+};
 
 // lib/solvers/TraceCleanupSolver/sub-solver/isPathColliding.ts
 import { getSegmentIntersection as getSegmentIntersection2 } from "@tscircuit/math-utils/line-intersections";
@@ -5913,6 +6057,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
   input;
   chipObstacleSpatialIndex;
   lShapesToProcess = [];
+  ignoredCrossings = /* @__PURE__ */ new Set();
+  reroutedTraceIds = /* @__PURE__ */ new Set();
+  processingCrossings = true;
   visualizationMode = "l_shapes";
   currentLShape = null;
   intersectionPoints = [];
@@ -5936,18 +6083,24 @@ var UntangleTraceSubsolver = class extends BaseSolver {
     if (!this.input.inputProblem._chipObstacleSpatialIndex) {
       this.input.inputProblem._chipObstacleSpatialIndex = this.chipObstacleSpatialIndex;
     }
-    for (const trace of this.input.allTraces) {
-      const lShapes = findAllLShapedTurns(trace.tracePath);
-      this.lShapesToProcess.push(
-        ...lShapes.map((l) => ({ ...l, traceId: trace.mspPairId }))
-      );
-    }
   }
   _step() {
     if (this.isInitialStep) {
       this.isInitialStep = false;
       return;
     }
+    if (this.processingCrossings) {
+      const crossing = this._findCrossing();
+      if (crossing) {
+        if (!this._resolveCrossing(crossing)) {
+          this.ignoredCrossings.add(this._crossingKey(crossing));
+        }
+        return;
+      }
+      this.processingCrossings = false;
+      this._initializeLShapes();
+      return;
+    }
     if (this.lShapeJustProcessed) {
       this._resetAfterLShapProcessing();
       return;
@@ -5971,6 +6124,110 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         break;
     }
   }
+  _initializeLShapes() {
+    for (const trace of this.input.allTraces) {
+      this.lShapesToProcess.push(
+        ...findAllLShapedTurns(trace.tracePath).map((lShape) => ({
+          ...lShape,
+          traceId: trace.mspPairId
+        }))
+      );
+    }
+  }
+  _crossingKey(crossing) {
+    return `${crossing.trace.mspPairId}:${crossing.segmentIndex}:${crossing.otherTrace.mspPairId}:${crossing.otherSegmentIndex}`;
+  }
+  _isTraceBundle(first, second) {
+    const componentPair = (trace) => trace.pins.map((pin) => pin.chipId).sort().join(":");
+    if (componentPair(first) !== componentPair(second)) return false;
+    return Object.values(this.input.mergedLabelNetIdMap).some(
+      (netIds) => netIds.has(first.globalConnNetId) && netIds.has(second.globalConnNetId)
+    );
+  }
+  _findCrossing() {
+    const traces = this.input.allTraces;
+    for (let firstIndex = 0; firstIndex < traces.length; firstIndex++) {
+      const trace = traces[firstIndex];
+      for (let secondIndex = firstIndex + 1; secondIndex < traces.length; secondIndex++) {
+        const otherTrace = traces[secondIndex];
+        if (trace.globalConnNetId === otherTrace.globalConnNetId) continue;
+        const isInitialBundleCrossing = this._isTraceBundle(trace, otherTrace);
+        if (!isInitialBundleCrossing && !this.reroutedTraceIds.has(trace.mspPairId) && !this.reroutedTraceIds.has(otherTrace.mspPairId)) {
+          continue;
+        }
+        const crossings = findPerpendicularPathCrossings(
+          trace.tracePath,
+          otherTrace.tracePath
+        );
+        for (const { pathSegmentIndex, otherPathSegmentIndex } of crossings) {
+          const crossing = {
+            trace,
+            segmentIndex: pathSegmentIndex,
+            otherTrace,
+            otherSegmentIndex: otherPathSegmentIndex,
+            isInitialBundleCrossing
+          };
+          if (!this.ignoredCrossings.has(this._crossingKey(crossing))) {
+            return crossing;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  _resolveCrossing(crossing) {
+    const chipBounds = this.chipObstacleSpatialIndex.chips.map(
+      (chip) => chip.bounds
+    );
+    const candidates = [
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.trace,
+        segmentIndex: crossing.segmentIndex,
+        obstacleStart: crossing.otherTrace.tracePath[crossing.otherSegmentIndex],
+        obstacleEnd: crossing.otherTrace.tracePath[crossing.otherSegmentIndex + 1],
+        chipBounds,
+        clearance: this.input.paddingBuffer
+      }),
+      ...generatePerpendicularTraceDetours({
+        trace: crossing.otherTrace,
+        segmentIndex: crossing.otherSegmentIndex,
+        obstacleStart: crossing.trace.tracePath[crossing.segmentIndex],
+        obstacleEnd: crossing.trace.tracePath[crossing.segmentIndex + 1],
+        chipBounds,
+        clearance: this.input.paddingBuffer
+      })
+    ];
+    const chipObstacles = getObstacleRects(this.input.inputProblem).filter(
+      (obstacle) => obstacle.kind === "chip"
+    );
+    const validCandidates = candidates.map((candidate) => ({
+      ...candidate,
+      collision: isPathColliding(
+        candidate.path,
+        this.input.allTraces,
+        candidate.traceId
+      )
+    })).filter(
+      (candidate) => !isPathCollidingWithChipInterior(candidate.path, chipObstacles) && !isPathColliding(
+        candidate.path,
+        [crossing.trace, crossing.otherTrace],
+        candidate.traceId
+      ).isColliding && (crossing.isInitialBundleCrossing || !candidate.collision.isColliding)
+    ).sort(
+      (first, second) => Number(first.collision.isColliding) - Number(second.collision.isColliding) || getPathLength(first.path) - getPathLength(second.path)
+    );
+    const bestCandidate = validCandidates[0];
+    if (!bestCandidate) return false;
+    const traceIndex = this.input.allTraces.findIndex(
+      (trace) => trace.mspPairId === bestCandidate.traceId
+    );
+    this.input.allTraces[traceIndex] = {
+      ...this.input.allTraces[traceIndex],
+      tracePath: bestCandidate.path
+    };
+    this.reroutedTraceIds.add(bestCandidate.traceId);
+    return true;
+  }
   _resetAfterLShapProcessing() {
     this.lShapeProcessingStep = "idle";
     this.currentLShape = null;
@@ -6193,9 +6450,9 @@ var UntangleTraceSubsolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
-var EPS8 = 1e-6;
-var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS8;
-var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS8;
+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;
@@ -6470,7 +6727,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;
       }
     }
@@ -6485,13 +6742,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);
   }
@@ -7255,16 +7512,16 @@ var createPortOnlyLabelConnectorTrace = ({
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
 var WICK_CLEARANCE = 1e-3;
-var EPS9 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS9;
+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) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS9;
+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;
@@ -7287,7 +7544,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     return false;
   }
   if (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS9 || p1.x >= interiorBounds.maxX - EPS9) {
+    if (p1.x <= interiorBounds.minX + EPS11 || p1.x >= interiorBounds.maxX - EPS11) {
       return false;
     }
     return rangesOverlap(
@@ -7298,7 +7555,7 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
     );
   }
   if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS9 || p1.y >= interiorBounds.maxY - EPS9) {
+    if (p1.y <= interiorBounds.minY + EPS11 || p1.y >= interiorBounds.maxY - EPS11) {
       return false;
     }
     return rangesOverlap(
@@ -7354,8 +7611,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) <= EPS9;
-var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS9;
+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),
@@ -7610,11 +7867,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) > EPS9 || Math.abs(point.y - label.anchorPoint.y) > EPS9) {
+        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) <= EPS9 && (neighbor.y - point.y) * direction.y > EPS9
+          (neighbor) => neighbor && Math.abs(neighbor.x - point.x) <= EPS11 && (neighbor.y - point.y) * direction.y > EPS11
         );
       });
     });
@@ -7693,7 +7950,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 + EPS9; 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
@@ -7767,7 +8024,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       phase = "shift",
       stopOnTraceCollision = true
     } = params;
-    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS9; distance4 += LABEL_SEARCH_STEP) {
+    for (let distance4 = LABEL_SEARCH_STEP; distance4 <= maxSearchDistance + EPS11; distance4 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance4,
         y: baseAnchor.y + direction.y * distance4
@@ -8004,9 +8261,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const { anchorPoint, orientation } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation)) {
-        return anchorPoint.x < chipBounds.minX - EPS9 || anchorPoint.x > chipBounds.maxX + EPS9;
+        return anchorPoint.x < chipBounds.minX - EPS11 || anchorPoint.x > chipBounds.maxX + EPS11;
       }
-      return anchorPoint.y < chipBounds.minY - EPS9 || anchorPoint.y > chipBounds.maxY + EPS9;
+      return anchorPoint.y < chipBounds.minY - EPS11 || anchorPoint.y > chipBounds.maxY + EPS11;
     });
   }
   getBoundsStatus(candidateBoundsCheck) {
@@ -8080,8 +8337,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 + EPS9 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS9;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS9 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS9;
+      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,
@@ -8129,7 +8386,7 @@ 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 - EPS9 || point.x > bounds.maxX + EPS9 || point.y < bounds.minY - EPS9 || point.y > bounds.maxY + EPS9) {
+      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)) {
@@ -8146,8 +8403,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 - EPS9 ? bounds.minX - point.x : point.x > bounds.maxX + EPS9 ? point.x - bounds.maxX : 0;
-      const dy = point.y < bounds.minY - EPS9 ? bounds.minY - point.y : point.y > bounds.maxY + EPS9 ? 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;
@@ -8431,8 +8688,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({
@@ -8525,11 +8782,11 @@ var getOrientationConstraint = (inputProblem, label) => {
 };
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
-var EPS10 = 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) > EPS10 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS10;
-var rectsTouchOrOverlap = (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 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;
@@ -8575,7 +8832,7 @@ var getPointAtTraceDistance = (trace, distance4) => {
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance4 <= nextDistance + EPS10) {
+    if (distance4 <= nextDistance + EPS12) {
       const offset = Math.max(
         0,
         Math.min(segmentLength, distance4 - pathDistance)
@@ -8614,7 +8871,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     return false;
   }
   if (isVertical4(start, end)) {
-    if (start.x <= interior.minX + EPS10 || start.x >= interior.maxX - EPS10) {
+    if (start.x <= interior.minX + EPS12 || start.x >= interior.maxX - EPS12) {
       return false;
     }
     return rangesOverlap2(
@@ -8625,7 +8882,7 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
     );
   }
   if (isHorizontal3(start, end)) {
-    if (start.y <= interior.minY + EPS10 || start.y >= interior.maxY - EPS10) {
+    if (start.y <= interior.minY + EPS12 || start.y >= interior.maxY - EPS12) {
       return false;
     }
     return rangesOverlap2(
@@ -8639,10 +8896,10 @@ var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
 };
 var isPointOnSegment2 = (point, start, end) => {
   if (isHorizontal3(start, end)) {
-    return Math.abs(point.y - start.y) <= EPS10 && point.x >= Math.min(start.x, end.x) - EPS10 && point.x <= Math.max(start.x, end.x) + EPS10;
+    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) <= EPS10 && point.y >= Math.min(start.y, end.y) - EPS10 && point.y <= Math.max(start.y, end.y) + EPS10;
+    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;
 };
@@ -8650,9 +8907,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) <= EPS10;
-var isVertical4 = (start, end) => Math.abs(start.x - end.x) <= EPS10;
-var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS10;
+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
@@ -8709,7 +8966,7 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   for (const distance4 of vertexDistances) {
     distances.add(roundDistance(distance4));
   }
-  return [...distances].filter((distance4) => distance4 >= -EPS10 && distance4 <= traceLength + EPS10).sort((a, b) => a - b);
+  return [...distances].filter((distance4) => distance4 >= -EPS12 && distance4 <= traceLength + EPS12).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -8798,13 +9055,13 @@ var getOutwardOrientationOptions = (point, chipBounds) => {
 };
 var getOutwardAxisOption = (params) => {
   const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
-  if (value > max + EPS10) {
+  if (value > max + EPS12) {
     return {
       orientation: positiveOrientation,
       outwardScore: 1 + value - max
     };
   }
-  if (value < min - EPS10) {
+  if (value < min - EPS12) {
     return {
       orientation: negativeOrientation,
       outwardScore: 1 + min - value
@@ -8815,7 +9072,7 @@ var getOutwardAxisOption = (params) => {
     outwardScore: getNormalizedCenterDistance(value, center, max - min)
   };
 };
-var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS10, 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) {
@@ -8888,7 +9145,7 @@ var getNetLabelHeight = (inputProblem, label) => {
   )?.netLabelHeight;
 };
 var roundDistance = (distance4) => Number(distance4.toFixed(6));
-var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS10 && Math.abs(point.y - label.anchorPoint.y) <= EPS10 && orientation === label.orientation;
+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";