@tscircuit/schematic-trace-solver 0.0.43 → 0.0.45

package/dist/index.js

@@ -271,19 +271,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS4 = 1e-9;
+  const EPS5 = 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) < -EPS4) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS5) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS4) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS5) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS4 || Math.abs(p1.y - p2.y) < EPS4) {
+  if (Math.abs(p1.x - p2.x) < EPS5 || Math.abs(p1.y - p2.y) < EPS5) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -810,8 +810,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS4 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS4 && Math.abs(p.y - q.y) < EPS4;
+      const EPS5 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS5 && Math.abs(p.y - q.y) < EPS5;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1010,17 +1010,17 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS4 = 1e-6
+  EPS: EPS5 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical2 = Math.abs(start.x - end.x) < EPS4;
-  const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
-  if (!isVertical2 && !isHorizontal2) return;
-  const segDir = isVertical2 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  const isVertical3 = Math.abs(start.x - end.x) < EPS5;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS5;
+  if (!isVertical3 && !isHorizontal2) return;
+  const segDir = isVertical3 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
-    if (isVertical2) {
+    if (isVertical3) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1040,7 +1040,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical2) {
+    if (isVertical3) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1083,13 +1083,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS4 = 1e-6;
+    const EPS5 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    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, gidx) => {
       const offset = offsets[gidx];
@@ -1115,15 +1115,15 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS4
+              EPS: EPS5
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical2 = Math.abs(start.x - end.x) < EPS4;
-            const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
-            if (!isVertical2 && !isHorizontal2) continue;
-            if (isVertical2) {
+            const isVertical3 = Math.abs(start.x - end.x) < EPS5;
+            const isHorizontal2 = Math.abs(start.y - end.y) < EPS5;
+            if (!isVertical3 && !isHorizontal2) continue;
+            if (isVertical3) {
               start.x += offset;
               end.x += offset;
             } else {
@@ -1188,6 +1188,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
    */
   traceNetIslands = {};
   correctedTraceMap = {};
+  cleanupPhase = null;
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -1217,7 +1218,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS4 = 2e-3;
+    const EPS5 = 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++) {
@@ -1235,7 +1236,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS4;
+          return overlap > EPS5;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1243,8 +1244,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) < EPS4;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS4;
+            const aVert = Math.abs(a1.x - a2.x) < EPS5;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS5;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -1252,11 +1253,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) < EPS4;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS4;
+                const bVert = Math.abs(b1.x - b2.x) < EPS5;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS5;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS4) {
+                  if (Math.abs(a1.x - b1.x) < EPS5) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1277,7 +1278,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS4) {
+                  if (Math.abs(a1.y - b1.y) < EPS5) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1314,6 +1315,47 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     }
     return null;
   }
+  findNextDiagonalSegment() {
+    const EPS5 = 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 isHorizontal2 = Math.abs(p1.y - p2.y) < EPS5;
+        const isVertical3 = Math.abs(p1.x - p2.x) < EPS5;
+        if (!isHorizontal2 && !isVertical3) {
+          return { mspPairId, tracePath, i, p1, p2 };
+        }
+      }
+    }
+    return null;
+  }
+  findAndFixNextDiagonalSegment() {
+    const diagonalInfo = this.findNextDiagonalSegment();
+    if (!diagonalInfo) {
+      return false;
+    }
+    const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
+    const EPS5 = 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) < EPS5 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS5 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS5 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS5 : false;
+    const elbow1 = { x: p1.x, y: p2.y };
+    const elbow2 = { x: p2.x, y: p1.y };
+    let score1 = 0;
+    if (prevIsVertical) score1++;
+    if (nextIsHorizontal) score1++;
+    let score2 = 0;
+    if (prevIsHorizontal) score2++;
+    if (nextIsVertical) score2++;
+    const elbowPoint = score1 < score2 ? elbow1 : elbow2;
+    tracePath.splice(i + 1, 0, elbowPoint);
+    return true;
+  }
   _step() {
     if (this.activeSubSolver?.solved) {
       for (const [mspPairId, newTrace] of Object.entries(
@@ -1330,6 +1372,17 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     }
     const overlapIssue = this.findNextOverlapIssue();
     if (overlapIssue === null) {
+      if (this.cleanupPhase === null) {
+        this.cleanupPhase = "diagonals";
+      }
+      if (this.cleanupPhase === "diagonals") {
+        const fixedDiagonal = this.findAndFixNextDiagonalSegment();
+        if (!fixedDiagonal) {
+          this.cleanupPhase = "done";
+          this.solved = true;
+        }
+        return;
+      }
       this.solved = true;
       return;
     }
@@ -1344,12 +1397,23 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return this.activeSubSolver.visualize();
     }
     const graphics = visualizeInputProblem(this.inputProblem);
+    graphics.circles = graphics.circles || [];
     for (const trace of Object.values(this.correctedTraceMap)) {
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "purple"
       });
     }
+    if (this.cleanupPhase === "diagonals") {
+      const diagonalInfo = this.findNextDiagonalSegment();
+      if (diagonalInfo) {
+        graphics.lines.push({
+          points: [diagonalInfo.p1, diagonalInfo.p2],
+          strokeColor: "red",
+          strokeWidth: 0.05
+        });
+      }
+    }
     return graphics;
   }
 };
@@ -1443,24 +1507,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS4 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS4;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS4;
+function segmentIntersectsRect2(p1, p2, rect, EPS5 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS5;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS5;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS4 || x > rect.maxX + EPS4) return false;
+    if (x < rect.minX - EPS5 || x > rect.maxX + EPS5) 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 > EPS4;
+    return overlap > EPS5;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS4 || y > rect.maxY + EPS4) return false;
+    if (y < rect.minY - EPS5 || y > rect.maxY + EPS5) 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 > EPS4;
+    return overlap > EPS5;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1829,14 +1893,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS4 = 1e-6;
+    const EPS5 = 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) < EPS4;
-        const isV = Math.abs(a.x - b.x) < EPS4;
+        const isH = Math.abs(a.y - b.y) < EPS5;
+        const isV = Math.abs(a.x - b.x) < EPS5;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -3099,12 +3163,21 @@ var LongDistancePairSolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/hasCollisions.ts
+import { segmentToBoxMinDistance } from "@tscircuit/math-utils";
 var hasCollisions = (pathSegments, obstacles) => {
   for (let i = 0; i < pathSegments.length - 1; i++) {
     const p1 = pathSegments[i];
     const p2 = pathSegments[i + 1];
     for (const obstacle of obstacles) {
-      if (segmentIntersectsRect(p1, p2, obstacle)) {
+      const box = {
+        center: {
+          x: obstacle.minX + (obstacle.maxX - obstacle.minX) / 2,
+          y: obstacle.minY + (obstacle.maxY - obstacle.minY) / 2
+        },
+        width: obstacle.maxX - obstacle.minX,
+        height: obstacle.maxY - obstacle.minY
+      };
+      if (segmentToBoxMinDistance(p1, p2, box) <= 0) {
         return true;
       }
     }
@@ -3154,43 +3227,60 @@ var hasCollisionsWithLabels = (pathSegments, labels) => {
   return false;
 };
 
+// lib/solvers/TraceCleanupSolver/recognizeStairStepPattern.ts
+var recognizeStairStepPattern = (pathToCheck, startIdx) => {
+  if (startIdx >= pathToCheck.length - 3) return -1;
+  let endIdx = startIdx;
+  let isStairStep = true;
+  for (let i = startIdx; i < pathToCheck.length - 2 && i < startIdx + 10; i++) {
+    if (i + 2 >= pathToCheck.length) break;
+    const p1 = pathToCheck[i];
+    const p2 = pathToCheck[i + 1];
+    const p3 = pathToCheck[i + 2];
+    const seg1Vertical = p1.x === p2.x;
+    const seg2Vertical = p2.x === p3.x;
+    if (seg1Vertical === seg2Vertical) {
+      break;
+    }
+    const seg1Direction = seg1Vertical ? Math.sign(p2.y - p1.y) : Math.sign(p2.x - p1.x);
+    if (i > startIdx) {
+      const prevP = pathToCheck[i - 1];
+      const prevSegVertical = prevP.x === p1.x;
+      const prevDirection = prevSegVertical ? Math.sign(p1.y - prevP.y) : Math.sign(p1.x - prevP.x);
+      if (seg1Vertical && prevSegVertical && seg1Direction !== prevDirection || !seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection) {
+        isStairStep = false;
+        break;
+      }
+    }
+    endIdx = i + 2;
+  }
+  return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
+};
+
+// lib/solvers/TraceCleanupSolver/isSegmentAnEndpointSegment.ts
+var isSegmentAnEndpointSegment = (p1, p2, originalPath) => {
+  if (originalPath.length < 2) return false;
+  const originalStart = originalPath[0];
+  const originalEnd = originalPath[originalPath.length - 1];
+  if (p1.x === originalStart.x && p1.y === originalStart.y && p2.x === originalPath[1].x && p2.y === originalPath[1].y) {
+    return true;
+  }
+  if (p1.x === originalPath[originalPath.length - 2].x && p1.y === originalPath[originalPath.length - 2].y && p2.x === originalEnd.x && p2.y === originalEnd.y) {
+    return true;
+  }
+  return false;
+};
+
 // lib/solvers/TraceCleanupSolver/turnMinimization.ts
 var minimizeTurns = ({
   path,
   obstacles,
-  labelBounds
+  labelBounds,
+  originalPath
 }) => {
   if (path.length <= 2) {
     return path;
   }
-  const recognizeStairStepPattern = (pathToCheck, startIdx) => {
-    if (startIdx >= pathToCheck.length - 3) return -1;
-    let endIdx = startIdx;
-    let isStairStep = true;
-    for (let i = startIdx; i < pathToCheck.length - 2 && i < startIdx + 10; i++) {
-      if (i + 2 >= pathToCheck.length) break;
-      const p1 = pathToCheck[i];
-      const p2 = pathToCheck[i + 1];
-      const p3 = pathToCheck[i + 2];
-      const seg1Vertical = p1.x === p2.x;
-      const seg2Vertical = p2.x === p3.x;
-      if (seg1Vertical === seg2Vertical) {
-        break;
-      }
-      const seg1Direction = seg1Vertical ? Math.sign(p2.y - p1.y) : Math.sign(p2.x - p1.x);
-      if (i > startIdx) {
-        const prevP = pathToCheck[i - 1];
-        const prevSegVertical = prevP.x === p1.x;
-        const prevDirection = prevSegVertical ? Math.sign(p1.y - prevP.y) : Math.sign(p1.x - prevP.x);
-        if (seg1Vertical && prevSegVertical && seg1Direction !== prevDirection || !seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection) {
-          isStairStep = false;
-          break;
-        }
-      }
-      endIdx = i + 2;
-    }
-    return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
-  };
   let optimizedPath = [...path];
   let currentTurns = countTurns(optimizedPath);
   let improved = true;
@@ -3199,6 +3289,17 @@ var minimizeTurns = ({
     for (let startIdx = 0; startIdx < optimizedPath.length - 3; startIdx++) {
       const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx);
       if (stairEndIdx > 0) {
+        if (isSegmentAnEndpointSegment(
+          optimizedPath[startIdx],
+          optimizedPath[startIdx + 1],
+          originalPath
+        ) || isSegmentAnEndpointSegment(
+          optimizedPath[stairEndIdx - 1],
+          optimizedPath[stairEndIdx],
+          originalPath
+        )) {
+          continue;
+        }
         const startPoint = optimizedPath[startIdx];
         const endPoint = optimizedPath[stairEndIdx];
         const connectionOptions = tryConnectPoints(startPoint, endPoint);
@@ -3233,6 +3334,17 @@ var minimizeTurns = ({
         for (let removeCount = 1; removeCount <= maxRemove; removeCount++) {
           const endIdx = startIdx + removeCount + 1;
           if (endIdx >= optimizedPath.length) continue;
+          if (isSegmentAnEndpointSegment(
+            optimizedPath[startIdx],
+            optimizedPath[startIdx + 1],
+            originalPath
+          ) || isSegmentAnEndpointSegment(
+            optimizedPath[endIdx - 1],
+            optimizedPath[endIdx],
+            originalPath
+          )) {
+            continue;
+          }
           const startPoint = optimizedPath[startIdx];
           const endPoint = optimizedPath[endIdx];
           const connectionOptions = tryConnectPoints(startPoint, endPoint);
@@ -3271,6 +3383,9 @@ var minimizeTurns = ({
         const p1 = optimizedPath[i];
         const p2 = optimizedPath[i + 1];
         const p3 = optimizedPath[i + 2];
+        if (isSegmentAnEndpointSegment(p1, p2, originalPath) || isSegmentAnEndpointSegment(p2, p3, originalPath)) {
+          continue;
+        }
         const allVertical = p1.x === p2.x && p2.x === p3.x;
         const allHorizontal = p1.y === p2.y && p2.y === p3.y;
         if (allVertical || allHorizontal) {
@@ -3327,7 +3442,15 @@ var minimizeTurnsWithFilteredLabels = ({
       };
     })
   );
-  const staticObstacles = getObstacleRects(inputProblem);
+  const staticObstaclesRaw = getObstacleRects(inputProblem);
+  const PADDING = 0.01;
+  const staticObstacles = staticObstaclesRaw.map((obs) => ({
+    ...obs,
+    minX: obs.minX - PADDING,
+    minY: obs.minY - PADDING,
+    maxX: obs.maxX + PADDING,
+    maxY: obs.maxY + PADDING
+  }));
   const combinedObstacles = [...staticObstacles, ...traceObstacles];
   const originalPath = targetTrace.tracePath;
   const filteredLabels = allLabelPlacements.filter((label) => {
@@ -3346,7 +3469,8 @@ var minimizeTurnsWithFilteredLabels = ({
   const newPath = minimizeTurns({
     path: originalPath,
     obstacles: combinedObstacles,
-    labelBounds
+    labelBounds,
+    originalPath
   });
   return {
     ...targetTrace,
@@ -3490,48 +3614,645 @@ var balanceZShapes = ({
   };
 };
 
+// lib/solvers/TraceCleanupSolver/sub-solver/findAllLShapedTurns.ts
+var findAllLShapedTurns = (tracePath) => {
+  const lShapes = [];
+  if (tracePath.length < 3) {
+    return lShapes;
+  }
+  for (let i = 0; i < tracePath.length - 2; i++) {
+    const p1 = tracePath[i];
+    const p2 = tracePath[i + 1];
+    const p3 = tracePath[i + 2];
+    const dx1 = p2.x - p1.x;
+    const dy1 = p2.y - p1.y;
+    const dx2 = p3.x - p2.x;
+    const dy2 = p3.y - p2.y;
+    if ((dx1 === 0 && dy2 === 0 && dy1 !== 0 && dx2 !== 0 || // Vertical then Horizontal
+    dy1 === 0 && dx2 === 0 && dx1 !== 0 && dy2 !== 0) && // Horizontal then Vertical
+    dx1 * dx1 + dy1 * dy1 >= 0.25 && // p1-p2 arm length >= 0.5
+    dx2 * dx2 + dy2 * dy2 >= 0.25) {
+      lShapes.push({ p1, p2, p3 });
+    }
+  }
+  return lShapes;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/getTraceObstacles.ts
+var getTraceObstacles = (allTraces, excludeTraceId) => {
+  const obstacles = [];
+  for (const trace of allTraces) {
+    if (trace.mspPairId !== excludeTraceId) {
+      obstacles.push({ points: trace.tracePath });
+    }
+  }
+  return obstacles;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
+import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
+var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
+  const intersections = [];
+  for (const obstacle of obstacles) {
+    const obstaclePath = obstacle.points;
+    for (let i = 0; i < obstaclePath.length - 1; i++) {
+      const o1 = obstaclePath[i];
+      const o2 = obstaclePath[i + 1];
+      if (!o1 || !o2) {
+        continue;
+      }
+      const intersection = getSegmentIntersection(p1, p2, o1, o2);
+      if (intersection) {
+        intersections.push(intersection);
+      }
+    }
+  }
+  return intersections;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
+var EPS4 = 1e-6;
+var isVertical2 = (a, b, eps = EPS4) => Math.abs(a.x - b.x) < eps;
+var generateLShapeRerouteCandidates = ({
+  lShape,
+  rectangle,
+  padding = 0.5,
+  interactionPoint1,
+  interactionPoint2
+}) => {
+  const { p1, p2, p3 } = lShape;
+  const { x, y, width, height } = rectangle;
+  let c2;
+  let i1_padded = interactionPoint1;
+  let i2_padded = interactionPoint2;
+  if (Math.abs(p2.x - x) < EPS4 && Math.abs(p2.y - (y + height)) < EPS4) {
+    c2 = { x: x + width + padding, y: y - padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
+    }
+  } else if (Math.abs(p2.x - (x + width)) < EPS4 && Math.abs(p2.y - (y + height)) < EPS4) {
+    c2 = { x: x - padding, y: y - padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
+    }
+  } else if (Math.abs(p2.x - x) < EPS4 && Math.abs(p2.y - y) < EPS4) {
+    c2 = { x: x + width + padding, y: y + height + padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
+    }
+  } else if (Math.abs(p2.x - (x + width)) < EPS4 && Math.abs(p2.y - y) < EPS4) {
+    c2 = { x: x - padding, y: y + height + padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
+    }
+  } else {
+    return [];
+  }
+  return [[i1_padded, c2, i2_padded]];
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/isPathColliding.ts
+import { getSegmentIntersection as getSegmentIntersection2 } from "@tscircuit/math-utils/line-intersections";
+var isPathColliding = (path, allTraces, traceIdToExclude) => {
+  if (path.length < 2) {
+    return { isColliding: false };
+  }
+  for (let i = 0; i < path.length - 1; i++) {
+    const pathSegP1 = path[i];
+    const pathSegQ1 = path[i + 1];
+    for (const existingTrace of allTraces) {
+      if (existingTrace.mspPairId === traceIdToExclude) {
+        continue;
+      }
+      for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
+        const existingSegP2 = existingTrace.tracePath[j];
+        const existingSegQ2 = existingTrace.tracePath[j + 1];
+        const intersectionPoint = getSegmentIntersection2(
+          pathSegP1,
+          pathSegQ1,
+          existingSegP2,
+          existingSegQ2
+        );
+        if (intersectionPoint) {
+          return {
+            isColliding: true,
+            collidingTraceId: existingTrace.mspPairId,
+            collisionPoint: intersectionPoint
+          };
+        }
+      }
+    }
+  }
+  return { isColliding: false };
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/generateRectangleCandidates.ts
+var generateRectangleCandidates = (intersections1, intersections2) => {
+  const rectangleCandidates = [];
+  for (const p1 of intersections1) {
+    for (const p2 of intersections2) {
+      const minX = Math.min(p1.x, p2.x);
+      const minY = Math.min(p1.y, p2.y);
+      const maxX = Math.max(p1.x, p2.x);
+      const maxY = Math.max(p1.y, p2.y);
+      const width = maxX - minX;
+      const height = maxY - minY;
+      if (width > 1e-6 && height > 1e-6) {
+        rectangleCandidates.push({
+          rect: {
+            x: minX,
+            y: minY,
+            width,
+            height
+          },
+          i1: p1,
+          i2: p2
+        });
+      }
+    }
+  }
+  return rectangleCandidates;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeLSapes.ts
+var visualizeLSapes = (lShapes) => {
+  const graphics = { circles: [], lines: [] };
+  const lShapesArray = Array.isArray(lShapes) ? lShapes : [lShapes];
+  for (const lShape of lShapesArray) {
+    graphics.circles.push({
+      center: {
+        x: lShape.p2.x,
+        y: lShape.p2.y
+      },
+      radius: 0.01,
+      fill: "blue"
+    });
+    graphics.lines.push({
+      points: [lShape.p1, lShape.p2, lShape.p3],
+      strokeColor: "lightblue"
+    });
+  }
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeIntersectionPoints.ts
+var visualizeIntersectionPoints = (points, color = "red") => {
+  const graphics = { circles: [] };
+  for (const point of points) {
+    graphics.circles.push({
+      center: {
+        x: point.x,
+        y: point.y
+      },
+      radius: 0.01,
+      fill: color
+    });
+  }
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/visualizeTightRectangle.ts
+var visualizeTightRectangle = (rectangle) => {
+  const graphics = { rects: [] };
+  graphics.rects.push({
+    center: {
+      x: rectangle.x + rectangle.width / 2,
+      y: rectangle.y + rectangle.height / 2
+    },
+    width: rectangle.width,
+    height: rectangle.height,
+    stroke: "green"
+  });
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeCandidates.ts
+var visualizeCandidates = (candidates, color = "gray", intersectionPoints = []) => {
+  const graphics = { lines: [], circles: [] };
+  for (const candidate of candidates) {
+    graphics.lines.push({
+      points: candidate,
+      strokeColor: color
+    });
+  }
+  for (const point of intersectionPoints) {
+    graphics.circles.push({
+      center: point,
+      radius: 0.01,
+      // Larger radius for intersection points
+      fill: "green"
+    });
+  }
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/mergeGraphicsObjects.ts
+var mergeGraphicsObjects = (objects) => {
+  const merged = {
+    lines: [],
+    points: [],
+    rects: [],
+    circles: [],
+    texts: []
+  };
+  for (const obj of objects) {
+    if (!obj) continue;
+    if (obj.lines) merged.lines.push(...obj.lines);
+    if (obj.points) merged.points.push(...obj.points);
+    if (obj.rects) merged.rects.push(...obj.rects);
+    if (obj.circles) merged.circles.push(...obj.circles);
+    if (obj.texts) merged.texts.push(...obj.texts);
+  }
+  return merged;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeCollision.ts
+var visualizeCollision = (collisionInfo) => {
+  const collisionGraphics = { circles: [] };
+  if (collisionInfo?.isColliding && collisionInfo.collisionPoint) {
+    collisionGraphics.circles.push({
+      center: collisionInfo.collisionPoint,
+      radius: 0.01,
+      fill: "red"
+    });
+  }
+  return collisionGraphics;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts
+var UntangleTraceSubsolver = class extends BaseSolver {
+  input;
+  lShapesToProcess = [];
+  visualizationMode = "l_shapes";
+  currentLShape = null;
+  intersectionPoints = [];
+  tightRectangle = null;
+  candidates = [];
+  bestRoute = null;
+  lastCollision = null;
+  collidingCandidate = null;
+  rectangleCandidates = [];
+  currentRectangleIndex = 0;
+  isInitialStep = true;
+  currentCandidateIndex = 0;
+  lShapeProcessingStep = "idle";
+  lShapeJustProcessed = false;
+  bestRouteFound = null;
+  constructor(solverInput) {
+    super();
+    this.input = solverInput;
+    this.visualizationMode = "l_shapes";
+    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.lShapeJustProcessed) {
+      this._resetAfterLShapProcessing();
+      return;
+    }
+    if (this.lShapesToProcess.length === 0 && this.currentLShape === null) {
+      this.solved = true;
+      return;
+    }
+    switch (this.lShapeProcessingStep) {
+      case "idle":
+        this._handleIdleStep();
+        break;
+      case "intersections":
+        this._handleIntersectionsStep();
+        break;
+      case "rectangle_selection":
+        this._handleRectangleSelectionStep();
+        break;
+      case "candidate_evaluation":
+        this._handleCandidateEvaluationStep();
+        break;
+    }
+  }
+  _resetAfterLShapProcessing() {
+    this.lShapeProcessingStep = "idle";
+    this.currentLShape = null;
+    this.currentCandidateIndex = 0;
+    this.lShapeJustProcessed = false;
+    this.visualizationMode = "l_shapes";
+    this.intersectionPoints = [];
+    this.tightRectangle = null;
+    this.candidates = [];
+    this.bestRoute = null;
+    this.lastCollision = null;
+    this.collidingCandidate = null;
+  }
+  _handleIdleStep() {
+    this.currentLShape = this.lShapesToProcess.shift();
+    if (!this.currentLShape) {
+      this.solved = true;
+      return;
+    }
+    this.lShapeProcessingStep = "intersections";
+    this.visualizationMode = "l_shapes";
+  }
+  _handleIntersectionsStep() {
+    if (!this.currentLShape.traceId) {
+      this.lShapeProcessingStep = "idle";
+      return;
+    }
+    const allObstacles = getTraceObstacles(
+      this.input.allTraces,
+      this.currentLShape.traceId
+    );
+    const intersections1 = findIntersectionsWithObstacles(
+      this.currentLShape.p1,
+      this.currentLShape.p2,
+      allObstacles
+    );
+    const intersections2 = findIntersectionsWithObstacles(
+      this.currentLShape.p2,
+      this.currentLShape.p3,
+      allObstacles
+    );
+    this.intersectionPoints = [...intersections1, ...intersections2];
+    if (intersections1.length === 0 || intersections2.length === 0) {
+      this.lShapeProcessingStep = "idle";
+      return;
+    }
+    this.rectangleCandidates = generateRectangleCandidates(
+      intersections1,
+      intersections2
+    );
+    this.currentRectangleIndex = 0;
+    this.lShapeProcessingStep = "rectangle_selection";
+  }
+  _handleRectangleSelectionStep() {
+    if (this.currentRectangleIndex >= this.rectangleCandidates.length) {
+      this.lShapeProcessingStep = "idle";
+      return;
+    }
+    const { rect, i1, i2 } = this.rectangleCandidates[this.currentRectangleIndex];
+    this.tightRectangle = rect;
+    this.candidates = generateLShapeRerouteCandidates({
+      lShape: this.currentLShape,
+      rectangle: this.tightRectangle,
+      padding: 2 * this.input.paddingBuffer,
+      interactionPoint1: i1,
+      interactionPoint2: i2
+    });
+    this.currentCandidateIndex = 0;
+    this.lastCollision = null;
+    this.collidingCandidate = null;
+    this.visualizationMode = "candidates";
+    this.lShapeProcessingStep = "candidate_evaluation";
+  }
+  _handleCandidateEvaluationStep() {
+    this.visualizationMode = "candidates";
+    if (this.bestRouteFound) {
+      this._applyBestRoute(this.bestRouteFound);
+      this.bestRouteFound = null;
+      return;
+    }
+    if (this.currentCandidateIndex >= this.candidates.length) {
+      this.currentRectangleIndex++;
+      this.lShapeProcessingStep = "rectangle_selection";
+      return;
+    }
+    const currentCandidate = this.candidates[this.currentCandidateIndex];
+    const collisionResult = isPathColliding(
+      currentCandidate,
+      this.input.allTraces,
+      this.currentLShape.traceId
+    );
+    if (!collisionResult?.isColliding) {
+      this.bestRouteFound = currentCandidate;
+      this.lastCollision = null;
+      this.collidingCandidate = null;
+    } else {
+      this.lastCollision = collisionResult;
+      this.collidingCandidate = currentCandidate;
+      this.currentCandidateIndex++;
+    }
+  }
+  _applyBestRoute(bestRoute) {
+    this.bestRoute = bestRoute;
+    this.collidingCandidate = null;
+    this.lastCollision = null;
+    const traceIndex = this.input.allTraces.findIndex(
+      (trace) => trace.mspPairId === this.currentLShape.traceId
+    );
+    if (traceIndex !== -1) {
+      const originalTrace = this.input.allTraces[traceIndex];
+      const p2Index = originalTrace.tracePath.findIndex(
+        (p) => p.x === this.currentLShape.p2.x && p.y === this.currentLShape.p2.y
+      );
+      if (p2Index !== -1) {
+        const newTracePath = [
+          ...originalTrace.tracePath.slice(0, p2Index),
+          ...bestRoute,
+          ...originalTrace.tracePath.slice(p2Index + 1)
+        ];
+        this.input.allTraces[traceIndex] = {
+          ...originalTrace,
+          tracePath: newTracePath
+        };
+        this.lShapesToProcess = this.lShapesToProcess.filter(
+          (l) => l.traceId !== this.currentLShape.traceId
+        );
+      }
+    }
+    this.lShapeJustProcessed = true;
+  }
+  getOutput() {
+    return { traces: this.input.allTraces };
+  }
+  visualize() {
+    switch (this.visualizationMode) {
+      case "l_shapes":
+        return visualizeLSapes(this.lShapesToProcess);
+      case "intersection_points":
+        return mergeGraphicsObjects([
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : void 0,
+          visualizeIntersectionPoints(this.intersectionPoints)
+        ]);
+      case "tight_rectangle":
+        return mergeGraphicsObjects([
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : void 0,
+          visualizeIntersectionPoints(this.intersectionPoints),
+          this.tightRectangle ? visualizeTightRectangle(this.tightRectangle) : void 0
+        ]);
+      case "candidates": {
+        if (this.lShapeJustProcessed) {
+          const allTracesGraphics2 = { lines: [] };
+          for (const trace of this.input.allTraces) {
+            const isUpdatedTrace = trace.mspPairId === this.currentLShape?.traceId;
+            for (let i = 0; i < trace.tracePath.length - 1; i++) {
+              allTracesGraphics2.lines.push({
+                points: [trace.tracePath[i], trace.tracePath[i + 1]],
+                strokeColor: isUpdatedTrace ? "green" : "#ccc"
+              });
+            }
+          }
+          return allTracesGraphics2;
+        }
+        const allTracesGraphics = { lines: [] };
+        for (const trace of this.input.allTraces) {
+          for (let i = 0; i < trace.tracePath.length - 1; i++) {
+            allTracesGraphics.lines.push({
+              points: [trace.tracePath[i], trace.tracePath[i + 1]],
+              strokeColor: "#ccc"
+              // Light gray for other traces
+            });
+          }
+        }
+        let candidateToDraw;
+        if (this.bestRouteFound) {
+          candidateToDraw = this.bestRouteFound;
+        } else if (this.lastCollision?.isColliding) {
+          candidateToDraw = this.collidingCandidate ?? void 0;
+        } else {
+          if (this.currentCandidateIndex < this.candidates.length) {
+            candidateToDraw = this.candidates[this.currentCandidateIndex];
+          }
+        }
+        return mergeGraphicsObjects([
+          allTracesGraphics,
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : void 0,
+          this.tightRectangle ? visualizeTightRectangle(this.tightRectangle) : void 0,
+          candidateToDraw ? visualizeCandidates(
+            [candidateToDraw],
+            this.bestRouteFound ? "green" : "blue",
+            this.intersectionPoints
+          ) : void 0,
+          this.lastCollision ? visualizeCollision(this.lastCollision) : void 0
+        ]);
+      }
+      default:
+        return {};
+    }
+  }
+};
+
+// lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
+var is4PointRectangle = (path) => {
+  if (path.length !== 4) return false;
+  const [p0, p1, p2, p3] = path;
+  const isHVHC = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x;
+  const isVHVC = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y;
+  return isHVHC || isVHVC;
+};
+
 // lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts
 var TraceCleanupSolver = class extends BaseSolver {
   input;
   outputTraces;
   traceIdQueue;
   tracesMap;
-  pipelineStep = "minimizing_turns";
+  pipelineStep = "untangling_traces";
   activeTraceId = null;
   // New property
+  activeSubSolver = null;
   constructor(solverInput) {
     super();
     this.input = solverInput;
     this.outputTraces = [...solverInput.allTraces];
     this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]));
-    this.traceIdQueue = Array.from(solverInput.targetTraceIds);
+    this.traceIdQueue = Array.from(
+      solverInput.allTraces.map((e) => e.mspPairId)
+    );
   }
   _step() {
-    if (this.pipelineStep === "minimizing_turns" && this.traceIdQueue.length === 0) {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        const output = this.activeSubSolver.getOutput();
+        this.outputTraces = output.traces;
+        this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]));
+        this.activeSubSolver = null;
+        this.pipelineStep = "minimizing_turns";
+      } else if (this.activeSubSolver.failed) {
+        this.activeSubSolver = null;
+        this.pipelineStep = "minimizing_turns";
+      }
+      return;
+    }
+    switch (this.pipelineStep) {
+      case "untangling_traces":
+        this._runUntangleTracesStep();
+        break;
+      case "minimizing_turns":
+        this._runMinimizeTurnsStep();
+        break;
+      case "balancing_l_shapes":
+        this._runBalanceLShapesStep();
+        break;
+    }
+  }
+  _runUntangleTracesStep() {
+    this.activeSubSolver = new UntangleTraceSubsolver({
+      ...this.input,
+      allTraces: Array.from(this.tracesMap.values())
+    });
+  }
+  _runMinimizeTurnsStep() {
+    if (this.traceIdQueue.length === 0) {
       this.pipelineStep = "balancing_l_shapes";
-      this.traceIdQueue = Array.from(this.input.targetTraceIds);
+      this.traceIdQueue = Array.from(
+        this.input.allTraces.map((e) => e.mspPairId)
+      );
+      return;
     }
-    if (this.pipelineStep === "balancing_l_shapes" && this.traceIdQueue.length === 0) {
+    this._processTrace("minimizing_turns");
+  }
+  _runBalanceLShapesStep() {
+    if (this.traceIdQueue.length === 0) {
       this.solved = true;
       return;
     }
+    this._processTrace("balancing_l_shapes");
+  }
+  _processTrace(step) {
     const targetMspConnectionPairId = this.traceIdQueue.shift();
     this.activeTraceId = targetMspConnectionPairId;
     const originalTrace = this.tracesMap.get(targetMspConnectionPairId);
-    const { tracePath } = originalTrace;
-    const is4PointRectangle = (path) => {
-      if (path.length !== 4) return false;
-      const [p0, p1, p2, p3] = path;
-      const isHVHC = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x;
-      const isVHVC = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y;
-      return isHVHC || isVHVC;
-    };
-    if (is4PointRectangle(tracePath)) {
+    if (is4PointRectangle(originalTrace.tracePath)) {
       return;
     }
     const allTraces = Array.from(this.tracesMap.values());
     let updatedTrace;
-    if (this.pipelineStep === "minimizing_turns") {
+    if (step === "minimizing_turns") {
       updatedTrace = minimizeTurnsWithFilteredLabels({
         ...this.input,
         targetMspConnectionPairId,
@@ -3553,6 +4274,9 @@ var TraceCleanupSolver = class extends BaseSolver {
     };
   }
   visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
     const graphics = visualizeInputProblem(this.input.inputProblem, {
       chipAlpha: 0.1,
       connectionAlpha: 0.1
@@ -3709,7 +4433,6 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: instance.inputProblem,
           allTraces: traces,
-          targetTraceIds: new Set(traces.map((t) => t.mspPairId)),
           allLabelPlacements: labelMergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
           paddingBuffer: 0.1