@tscircuit/schematic-trace-solver 0.0.42 → 0.0.43

package/dist/index.js

@@ -2352,37 +2352,182 @@ var MergedNetLabelObstacleSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/hasCollisions.ts
-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)) {
-        return true;
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap.ts
+var detectTraceLabelOverlap = (traces, netLabels) => {
+  const overlaps = [];
+  for (const trace of traces) {
+    for (const label of netLabels) {
+      const labelBounds = getRectBounds(label.center, label.width, label.height);
+      for (let i = 0; i < trace.tracePath.length - 1; i++) {
+        const p1 = trace.tracePath[i];
+        const p2 = trace.tracePath[i + 1];
+        if (segmentIntersectsRect2(p1, p2, labelBounds)) {
+          if (trace.globalConnNetId === label.globalConnNetId) {
+            break;
+          }
+          overlaps.push({ trace, label });
+          break;
+        }
       }
     }
   }
-  return false;
+  return overlaps;
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/countTurns.ts
-var countTurns = (points) => {
-  let turns = 0;
-  for (let i = 1; i < points.length - 1; i++) {
-    const prev = points[i - 1];
-    const curr = points[i];
-    const next = points[i + 1];
-    const prevVertical = prev.x === curr.x;
-    const nextVertical = curr.x === next.x;
-    if (prevVertical !== nextVertical) {
-      turns++;
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/violation.ts
+var findTraceViolationZone = (path, labelBounds) => {
+  const isPointInside = (p) => p.x > labelBounds.minX && p.x < labelBounds.maxX && p.y > labelBounds.minY && p.y < labelBounds.maxY;
+  let firstInsideIndex = -1;
+  let lastInsideIndex = -1;
+  for (let i = 0; i < path.length; i++) {
+    if (isPointInside(path[i])) {
+      if (firstInsideIndex === -1) {
+        firstInsideIndex = i;
+      }
+      lastInsideIndex = i;
     }
   }
-  return turns;
+  return { firstInsideIndex, lastInsideIndex };
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts
+var generateSnipAndReconnectCandidates = ({
+  initialTrace,
+  firstInsideIndex,
+  lastInsideIndex,
+  labelBounds,
+  paddingBuffer,
+  detourCount
+}) => {
+  if (firstInsideIndex <= 0 || lastInsideIndex >= initialTrace.tracePath.length - 1) {
+    return [];
+  }
+  const entryPoint = initialTrace.tracePath[firstInsideIndex - 1];
+  const exitPoint = initialTrace.tracePath[lastInsideIndex + 1];
+  const pathToEntry = initialTrace.tracePath.slice(0, firstInsideIndex);
+  const pathFromExit = initialTrace.tracePath.slice(lastInsideIndex + 1);
+  const allCandidateDetours = [];
+  if (entryPoint.x !== exitPoint.x && entryPoint.y !== exitPoint.y) {
+    allCandidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }]);
+    allCandidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }]);
+  } else if (entryPoint.x === exitPoint.x || entryPoint.y === exitPoint.y) {
+    allCandidateDetours.push([]);
+  }
+  const buffer = paddingBuffer + detourCount * paddingBuffer;
+  const leftX = labelBounds.minX - buffer;
+  const rightX = labelBounds.maxX + buffer;
+  const topY = labelBounds.maxY + buffer;
+  const bottomY = labelBounds.minY - buffer;
+  if ((entryPoint.x <= labelBounds.minX || exitPoint.x <= labelBounds.minX) && entryPoint.x < labelBounds.maxX && exitPoint.x < labelBounds.maxX) {
+    allCandidateDetours.push([
+      { x: leftX, y: entryPoint.y },
+      { x: leftX, y: exitPoint.y }
+    ]);
+  }
+  if ((entryPoint.x >= labelBounds.maxX || exitPoint.x >= labelBounds.maxX) && entryPoint.x > labelBounds.minX && exitPoint.x > labelBounds.minX) {
+    allCandidateDetours.push([
+      { x: rightX, y: entryPoint.y },
+      { x: rightX, y: exitPoint.y }
+    ]);
+  }
+  if ((entryPoint.y >= labelBounds.maxY || exitPoint.y >= labelBounds.maxY) && entryPoint.y > labelBounds.minY && exitPoint.y > labelBounds.minY) {
+    allCandidateDetours.push([
+      { x: entryPoint.x, y: topY },
+      { x: exitPoint.x, y: topY }
+    ]);
+  }
+  if ((entryPoint.y <= labelBounds.minY || exitPoint.y <= labelBounds.minY) && entryPoint.y < labelBounds.maxY && exitPoint.y < labelBounds.maxY) {
+    allCandidateDetours.push([
+      { x: entryPoint.x, y: bottomY },
+      { x: exitPoint.x, y: bottomY }
+    ]);
+  }
+  return allCandidateDetours.map((detour) => [
+    ...pathToEntry,
+    ...detour,
+    ...pathFromExit
+  ]);
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts
+var generateFourPointDetourCandidates = ({
+  initialTrace,
+  label,
+  labelBounds,
+  paddingBuffer,
+  detourCount
+}) => {
+  let collidingSegIndex = -1;
+  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
+    if (segmentIntersectsRect(
+      initialTrace.tracePath[i],
+      initialTrace.tracePath[i + 1],
+      labelBounds
+    )) {
+      collidingSegIndex = i;
+      break;
+    }
+  }
+  if (collidingSegIndex === -1) return [];
+  const pA = initialTrace.tracePath[collidingSegIndex];
+  const pB = initialTrace.tracePath[collidingSegIndex + 1];
+  if (!pA || !pB) return [];
+  const candidateDetours = [];
+  const paddedLabelBounds = getRectBounds(
+    label.center,
+    label.width,
+    label.height
+  );
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
+  if (isVertical(pA, pB)) {
+    const xCandidates = [
+      paddedLabelBounds.maxX + effectivePadding,
+      paddedLabelBounds.minX - effectivePadding
+    ];
+    for (const newX of xCandidates) {
+      candidateDetours.push(
+        pB.y > pA.y ? [
+          { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
+          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+          { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding }
+        ] : [
+          { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
+          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
+          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
+          { x: pB.x, y: paddedLabelBounds.minY - effectivePadding }
+        ]
+      );
+    }
+  } else {
+    const yCandidates = [
+      paddedLabelBounds.maxY + effectivePadding,
+      paddedLabelBounds.minY - effectivePadding
+    ];
+    for (const newY of yCandidates) {
+      candidateDetours.push(
+        pB.x > pA.x ? [
+          { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
+          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+          { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y }
+        ] : [
+          { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
+          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
+          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
+          { x: paddedLabelBounds.minX - effectivePadding, y: pB.y }
+        ]
+      );
+    }
+  }
+  return candidateDetours.map((detourPoints) => [
+    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+    ...detourPoints,
+    ...initialTrace.tracePath.slice(collidingSegIndex + 1)
+  ]);
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/simplifyPath.ts
+// lib/solvers/TraceCleanupSolver/simplifyPath.ts
 var simplifyPath = (path) => {
   if (path.length < 3) return path;
   const newPath = [path[0]];
@@ -2411,675 +2556,46 @@ var simplifyPath = (path) => {
   return finalPath;
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/tryConnectPoints.ts
-var tryConnectPoints = (start, end) => {
-  const candidates = [];
-  if (start.x === end.x || start.y === end.y) {
-    candidates.push([start, end]);
-  } else {
-    candidates.push([start, { x: end.x, y: start.y }, end]);
-    candidates.push([start, { x: start.x, y: end.y }, end]);
-  }
-  return candidates;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/hasCollisionsWithLabels.ts
-var hasCollisionsWithLabels = (pathSegments, labels) => {
-  for (let i = 0; i < pathSegments.length - 1; i++) {
-    const p1 = pathSegments[i];
-    const p2 = pathSegments[i + 1];
-    for (const label of labels) {
-      if (segmentIntersectsRect(p1, p2, label)) {
-        return true;
-      }
-    }
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts
+var generateRerouteCandidates = ({
+  trace,
+  label,
+  paddingBuffer,
+  detourCount
+}) => {
+  const initialTrace = { ...trace, tracePath: simplifyPath(trace.tracePath) };
+  if (trace.globalConnNetId === label.globalConnNetId) {
+    return [initialTrace.tracePath];
   }
-  return false;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/turnMinimization.ts
-var minimizeTurns = ({
-  path,
-  obstacles,
-  labelBounds
-}) => {
-  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;
-  while (improved) {
-    improved = false;
-    for (let startIdx = 0; startIdx < optimizedPath.length - 3; startIdx++) {
-      const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx);
-      if (stairEndIdx > 0) {
-        const startPoint = optimizedPath[startIdx];
-        const endPoint = optimizedPath[stairEndIdx];
-        const connectionOptions = tryConnectPoints(startPoint, endPoint);
-        for (const connection of connectionOptions) {
-          const testPath = [
-            ...optimizedPath.slice(0, startIdx + 1),
-            ...connection.slice(1, -1),
-            ...optimizedPath.slice(stairEndIdx)
-          ];
-          const collidesWithObstacles = hasCollisions(connection, obstacles);
-          const collidesWithLabels = hasCollisionsWithLabels(
-            connection,
-            labelBounds
-          );
-          if (!collidesWithObstacles && !collidesWithLabels) {
-            const newTurns = countTurns(testPath);
-            optimizedPath = testPath;
-            currentTurns = newTurns;
-            improved = true;
-            break;
-          }
-        }
-        if (improved) break;
-      }
-    }
-    if (!improved) {
-      for (let startIdx = 0; startIdx < optimizedPath.length - 2; startIdx++) {
-        const maxRemove = Math.min(
-          optimizedPath.length - startIdx - 2,
-          optimizedPath.length - 2
-        );
-        for (let removeCount = 1; removeCount <= maxRemove; removeCount++) {
-          const endIdx = startIdx + removeCount + 1;
-          if (endIdx >= optimizedPath.length) continue;
-          const startPoint = optimizedPath[startIdx];
-          const endPoint = optimizedPath[endIdx];
-          const connectionOptions = tryConnectPoints(startPoint, endPoint);
-          for (const connection of connectionOptions) {
-            const testPath = [
-              ...optimizedPath.slice(0, startIdx + 1),
-              ...connection.slice(1, -1),
-              ...optimizedPath.slice(endIdx)
-            ];
-            const connectionSegments = connection;
-            const collidesWithObstacles = hasCollisions(
-              connectionSegments,
-              obstacles
-            );
-            const collidesWithLabels = hasCollisionsWithLabels(
-              connectionSegments,
-              labelBounds
-            );
-            if (!collidesWithObstacles && !collidesWithLabels) {
-              const newTurns = countTurns(testPath);
-              if (newTurns < currentTurns || newTurns === currentTurns && testPath.length < optimizedPath.length) {
-                optimizedPath = testPath;
-                currentTurns = newTurns;
-                improved = true;
-                break;
-              }
-            }
-          }
-          if (improved) break;
-        }
-        if (improved) break;
-      }
-    }
-    if (!improved) {
-      for (let i = 0; i < optimizedPath.length - 2; i++) {
-        const p1 = optimizedPath[i];
-        const p2 = optimizedPath[i + 1];
-        const p3 = optimizedPath[i + 2];
-        const allVertical = p1.x === p2.x && p2.x === p3.x;
-        const allHorizontal = p1.y === p2.y && p2.y === p3.y;
-        if (allVertical || allHorizontal) {
-          const testPath = [
-            ...optimizedPath.slice(0, i + 1),
-            ...optimizedPath.slice(i + 2)
-          ];
-          const collidesWithObstacles = hasCollisions([p1, p3], obstacles);
-          const collidesWithLabels = hasCollisionsWithLabels(
-            [p1, p3],
-            labelBounds
-          );
-          if (!collidesWithObstacles && !collidesWithLabels) {
-            optimizedPath = testPath;
-            improved = true;
-            break;
-          }
-        }
-      }
-    }
-  }
-  const finalSimplifiedPath = simplifyPath(optimizedPath);
-  return finalSimplifiedPath;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts
-var minimizeTurnsWithFilteredLabels = ({
-  traces,
-  inputProblem,
-  allLabelPlacements,
-  mergedLabelNetIdMap,
-  paddingBuffer
-}) => {
-  let changesMade = false;
-  const obstacles = getObstacleRects(inputProblem);
-  const newTraces = traces.map((trace) => {
-    const originalPath = trace.tracePath;
-    const filteredLabels = allLabelPlacements.filter((label) => {
-      const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
-      if (originalNetIds) {
-        return !originalNetIds.has(trace.globalConnNetId);
-      }
-      return label.globalConnNetId !== trace.globalConnNetId;
-    });
-    const labelBounds = filteredLabels.map((nl) => ({
-      minX: nl.center.x - nl.width / 2 - paddingBuffer,
-      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
-      minY: nl.center.y - nl.height / 2 - paddingBuffer,
-      maxY: nl.center.y + nl.height / 2 + paddingBuffer
-    }));
-    const newPath = minimizeTurns({
-      path: originalPath,
-      obstacles,
-      labelBounds
-    });
-    if (newPath.length !== originalPath.length || newPath.some(
-      (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y
-    )) {
-      changesMade = true;
-    }
-    return {
-      ...trace,
-      tracePath: newPath
-    };
-  });
-  if (changesMade) {
-    return newTraces;
-  } else {
-    return null;
-  }
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/balanceLShapes.ts
-var balanceLShapes = ({
-  traces,
-  inputProblem,
-  allLabelPlacements
-}) => {
-  const TOLERANCE = 1e-5;
-  let changesMade = false;
-  for (const trace of traces) {
-    if (trace.tracePath.length === 4) {
-      const [p0, p1, p2, p3] = trace.tracePath;
-      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y;
-      const isVHVShape = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x;
-      const isCollinearHorizontal = p0.y === p1.y && p1.y === p2.y && p2.y === p3.y;
-      const isCollinearVertical = p0.x === p1.x && p1.x === p2.x && p2.x === p3.x;
-      const isCollinear = isCollinearHorizontal || isCollinearVertical;
-      let isSameDirection = false;
-      if (isHVHShape) {
-        isSameDirection = Math.sign(p1.x - p0.x) === Math.sign(p3.x - p2.x);
-      } else if (isVHVShape) {
-        isSameDirection = Math.sign(p1.y - p0.y) === Math.sign(p3.y - p2.y);
-      }
-      const isValidZShape = (isHVHShape || isVHVShape) && !isCollinear && isSameDirection;
-      if (!isValidZShape) {
-        return null;
-      }
-    }
-  }
-  const obstacles = getObstacleRects(inputProblem).map((obs) => ({
-    ...obs,
-    minX: obs.minX + TOLERANCE,
-    maxX: obs.maxX - TOLERANCE,
-    minY: obs.minY + TOLERANCE,
-    maxY: obs.maxY - TOLERANCE
-  }));
-  const segmentIntersectsAnyRect = (p1, p2, rects) => {
-    for (const rect of rects) {
-      if (segmentIntersectsRect(p1, p2, rect)) {
-        return true;
-      }
-    }
-    return false;
-  };
-  const getLabelBounds = (labels, traceNetId) => {
-    const filteredLabels = labels.filter(
-      (label) => label.globalConnNetId !== traceNetId
-    );
-    return filteredLabels.map((nl) => ({
-      minX: nl.center.x - nl.width / 2 + TOLERANCE,
-      maxX: nl.center.x + nl.width / 2 - TOLERANCE,
-      minY: nl.center.y - nl.height / 2 + TOLERANCE,
-      maxY: nl.center.y + nl.height / 2 - TOLERANCE
-    }));
-  };
-  const newTraces = traces.map((trace) => {
-    const newPath = [...trace.tracePath];
-    if (newPath.length < 4) {
-      return { ...trace };
-    }
-    const labelBounds = getLabelBounds(
-      allLabelPlacements,
-      trace.globalConnNetId
-    );
-    if (newPath.length === 4) {
-      const [p0, p1, p2, p3] = newPath;
-      let p1New;
-      let p2New;
-      const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y;
-      if (isHVHShape) {
-        const idealX = (p0.x + p3.x) / 2;
-        p1New = { x: idealX, y: p1.y };
-        p2New = { x: idealX, y: p2.y };
-      } else {
-        const idealY = (p0.y + p3.y) / 2;
-        p1New = { x: p1.x, y: idealY };
-        p2New = { x: p2.x, y: idealY };
-      }
-      const collides = segmentIntersectsAnyRect(p0, p1New, obstacles) || segmentIntersectsAnyRect(p1New, p2New, obstacles) || segmentIntersectsAnyRect(p2New, p3, obstacles) || segmentIntersectsAnyRect(p0, p1New, labelBounds) || segmentIntersectsAnyRect(p1New, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3, labelBounds);
-      if (!collides) {
-        newPath[1] = p1New;
-        newPath[2] = p2New;
-        changesMade = true;
-      }
-      return { ...trace, tracePath: simplifyPath(newPath) };
-    }
-    for (let i = 1; i < newPath.length - 4; i++) {
-      const p1 = newPath[i];
-      const p2 = newPath[i + 1];
-      const p3 = newPath[i + 2];
-      const p4 = newPath[i + 3];
-      const isHVHZShape = p1.y === p2.y && p2.x === p3.x && p3.y === p4.y;
-      const isVHVZShape = p1.x === p2.x && p2.y === p3.y && p3.x === p4.x;
-      const isCollinearHorizontal = p1.y === p2.y && p2.y === p3.y && p3.y === p4.y;
-      const isCollinearVertical = p1.x === p2.x && p2.x === p3.x && p3.x === p4.x;
-      const isCollinear = isCollinearHorizontal || isCollinearVertical;
-      let isSameDirection = false;
-      if (isHVHZShape) {
-        isSameDirection = Math.sign(p2.x - p1.x) === Math.sign(p4.x - p3.x);
-      } else if (isVHVZShape) {
-        isSameDirection = Math.sign(p2.y - p1.y) === Math.sign(p4.y - p3.y);
-      }
-      const isValidZShape = (isHVHZShape || isVHVZShape) && !isCollinear && isSameDirection;
-      if (!isValidZShape) {
-        continue;
-      }
-      let p2New;
-      let p3New;
-      const len1Original = isHVHZShape ? Math.abs(p1.x - p2.x) : Math.abs(p1.y - p2.y);
-      const len2Original = isHVHZShape ? Math.abs(p3.x - p4.x) : Math.abs(p3.y - p4.y);
-      if (Math.abs(len1Original - len2Original) < 1e-3) {
-        continue;
-      }
-      if (isHVHZShape) {
-        const idealX = (p1.x + p4.x) / 2;
-        p2New = { x: idealX, y: p2.y };
-        p3New = { x: idealX, y: p3.y };
-      } else {
-        const idealY = (p1.y + p4.y) / 2;
-        p2New = { x: p2.x, y: idealY };
-        p3New = { x: p3.x, y: idealY };
-      }
-      const collides = segmentIntersectsAnyRect(p1, p2New, obstacles) || segmentIntersectsAnyRect(p2New, p3New, obstacles) || segmentIntersectsAnyRect(p3New, p4, obstacles) || segmentIntersectsAnyRect(p1, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3New, labelBounds) || segmentIntersectsAnyRect(p3New, p4, labelBounds);
-      if (!collides) {
-        newPath[i + 1] = p2New;
-        newPath[i + 2] = p3New;
-        changesMade = true;
-        i = 0;
-      }
-    }
-    const finalSimplifiedPath = simplifyPath(newPath);
-    return {
-      ...trace,
-      tracePath: finalSimplifiedPath
-    };
-  });
-  if (changesMade) {
-    return newTraces;
-  } else {
-    return null;
-  }
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/TraceCleanupSolver.ts
-var TraceCleanupSolver = class extends BaseSolver {
-  input;
-  outputTraces;
-  pipelineStepIndex = 0;
-  tracesToProcess;
-  minimizedTraces = null;
-  balancedTraces = null;
-  constructor(solverInput) {
-    super();
-    this.input = solverInput;
-    this.outputTraces = [...solverInput.allTraces];
-    this.tracesToProcess = this.outputTraces.filter(
-      (t) => this.input.targetTraceIds.has(t.mspPairId)
-    );
-  }
-  _step() {
-    const {
-      targetTraceIds,
-      inputProblem,
-      allLabelPlacements,
-      mergedLabelNetIdMap,
-      paddingBuffer
-    } = this.input;
-    if (targetTraceIds.size === 0) {
-      this.solved = true;
-      return;
-    }
-    switch (this.pipelineStepIndex) {
-      case 0: {
-        const minimizedTracesResult = minimizeTurnsWithFilteredLabels({
-          traces: this.tracesToProcess,
-          inputProblem,
-          allLabelPlacements,
-          mergedLabelNetIdMap,
-          paddingBuffer
-        });
-        this.minimizedTraces = minimizedTracesResult ?? this.tracesToProcess;
-        const tracesMap = new Map(
-          this.input.allTraces.map((t) => [t.mspPairId, t])
-        );
-        for (const trace of this.minimizedTraces) {
-          tracesMap.set(trace.mspPairId, trace);
-        }
-        this.outputTraces = Array.from(tracesMap.values());
-        this.pipelineStepIndex++;
-        break;
-      }
-      case 1: {
-        const balancedTracesResult = balanceLShapes({
-          traces: this.minimizedTraces,
-          inputProblem,
-          allLabelPlacements
-        });
-        this.balancedTraces = balancedTracesResult ?? this.minimizedTraces;
-        const tracesMap = new Map(
-          this.input.allTraces.map((t) => [t.mspPairId, t])
-        );
-        for (const trace of this.balancedTraces) {
-          tracesMap.set(trace.mspPairId, trace);
-        }
-        this.outputTraces = Array.from(tracesMap.values());
-        this.pipelineStepIndex++;
-        break;
-      }
-      case 2: {
-        this.solved = true;
-        break;
-      }
-    }
-  }
-  getOutput() {
-    return {
-      traces: this.outputTraces
-    };
-  }
-  visualize() {
-    const graphics = visualizeInputProblem(this.input.inputProblem, {
-      chipAlpha: 0.1,
-      connectionAlpha: 0.1
-    });
-    if (!graphics.lines) graphics.lines = [];
-    if (!graphics.points) graphics.points = [];
-    if (!graphics.rects) graphics.rects = [];
-    if (!graphics.circles) graphics.circles = [];
-    if (!graphics.texts) graphics.texts = [];
-    for (const trace of this.outputTraces) {
-      const line = {
-        points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
-        strokeColor: "blue"
-      };
-      graphics.lines.push(line);
-    }
-    return graphics;
-  }
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap.ts
-var detectTraceLabelOverlap = (traces, netLabels) => {
-  const overlaps = [];
-  for (const trace of traces) {
-    for (const label of netLabels) {
-      const labelBounds = getRectBounds(label.center, label.width, label.height);
-      for (let i = 0; i < trace.tracePath.length - 1; i++) {
-        const p1 = trace.tracePath[i];
-        const p2 = trace.tracePath[i + 1];
-        if (segmentIntersectsRect2(p1, p2, labelBounds)) {
-          if (trace.globalConnNetId === label.globalConnNetId) {
-            break;
-          }
-          overlaps.push({ trace, label });
-          break;
-        }
-      }
-    }
-  }
-  return overlaps;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/violation.ts
-var findTraceViolationZone = (path, labelBounds) => {
-  const isPointInside = (p) => p.x > labelBounds.minX && p.x < labelBounds.maxX && p.y > labelBounds.minY && p.y < labelBounds.maxY;
-  let firstInsideIndex = -1;
-  let lastInsideIndex = -1;
-  for (let i = 0; i < path.length; i++) {
-    if (isPointInside(path[i])) {
-      if (firstInsideIndex === -1) {
-        firstInsideIndex = i;
-      }
-      lastInsideIndex = i;
-    }
-  }
-  return { firstInsideIndex, lastInsideIndex };
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts
-var generateSnipAndReconnectCandidates = ({
-  initialTrace,
-  firstInsideIndex,
-  lastInsideIndex,
-  labelBounds,
-  paddingBuffer,
-  detourCount
-}) => {
-  if (firstInsideIndex <= 0 || lastInsideIndex >= initialTrace.tracePath.length - 1) {
-    return [];
-  }
-  const entryPoint = initialTrace.tracePath[firstInsideIndex - 1];
-  const exitPoint = initialTrace.tracePath[lastInsideIndex + 1];
-  const pathToEntry = initialTrace.tracePath.slice(0, firstInsideIndex);
-  const pathFromExit = initialTrace.tracePath.slice(lastInsideIndex + 1);
-  const allCandidateDetours = [];
-  if (entryPoint.x !== exitPoint.x && entryPoint.y !== exitPoint.y) {
-    allCandidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }]);
-    allCandidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }]);
-  } else if (entryPoint.x === exitPoint.x || entryPoint.y === exitPoint.y) {
-    allCandidateDetours.push([]);
-  }
-  const buffer = paddingBuffer + detourCount * paddingBuffer;
-  const leftX = labelBounds.minX - buffer;
-  const rightX = labelBounds.maxX + buffer;
-  const topY = labelBounds.maxY + buffer;
-  const bottomY = labelBounds.minY - buffer;
-  if ((entryPoint.x <= labelBounds.minX || exitPoint.x <= labelBounds.minX) && entryPoint.x < labelBounds.maxX && exitPoint.x < labelBounds.maxX) {
-    allCandidateDetours.push([
-      { x: leftX, y: entryPoint.y },
-      { x: leftX, y: exitPoint.y }
-    ]);
-  }
-  if ((entryPoint.x >= labelBounds.maxX || exitPoint.x >= labelBounds.maxX) && entryPoint.x > labelBounds.minX && exitPoint.x > labelBounds.minX) {
-    allCandidateDetours.push([
-      { x: rightX, y: entryPoint.y },
-      { x: rightX, y: exitPoint.y }
-    ]);
-  }
-  if ((entryPoint.y >= labelBounds.maxY || exitPoint.y >= labelBounds.maxY) && entryPoint.y > labelBounds.minY && exitPoint.y > labelBounds.minY) {
-    allCandidateDetours.push([
-      { x: entryPoint.x, y: topY },
-      { x: exitPoint.x, y: topY }
-    ]);
-  }
-  if ((entryPoint.y <= labelBounds.minY || exitPoint.y <= labelBounds.minY) && entryPoint.y < labelBounds.maxY && exitPoint.y < labelBounds.maxY) {
-    allCandidateDetours.push([
-      { x: entryPoint.x, y: bottomY },
-      { x: exitPoint.x, y: bottomY }
-    ]);
-  }
-  return allCandidateDetours.map((detour) => [
-    ...pathToEntry,
-    ...detour,
-    ...pathFromExit
-  ]);
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts
-var generateFourPointDetourCandidates = ({
-  initialTrace,
-  label,
-  labelBounds,
-  paddingBuffer,
-  detourCount
-}) => {
-  let collidingSegIndex = -1;
-  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
-    if (segmentIntersectsRect(
-      initialTrace.tracePath[i],
-      initialTrace.tracePath[i + 1],
-      labelBounds
-    )) {
-      collidingSegIndex = i;
-      break;
-    }
-  }
-  if (collidingSegIndex === -1) return [];
-  const pA = initialTrace.tracePath[collidingSegIndex];
-  const pB = initialTrace.tracePath[collidingSegIndex + 1];
-  if (!pA || !pB) return [];
-  const candidateDetours = [];
-  const paddedLabelBounds = getRectBounds(
-    label.center,
-    label.width,
-    label.height
-  );
-  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
-  if (isVertical(pA, pB)) {
-    const xCandidates = [
-      paddedLabelBounds.maxX + effectivePadding,
-      paddedLabelBounds.minX - effectivePadding
-    ];
-    for (const newX of xCandidates) {
-      candidateDetours.push(
-        pB.y > pA.y ? [
-          { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
-          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-          { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding }
-        ] : [
-          { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
-          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-          { x: pB.x, y: paddedLabelBounds.minY - effectivePadding }
-        ]
-      );
-    }
-  } else {
-    const yCandidates = [
-      paddedLabelBounds.maxY + effectivePadding,
-      paddedLabelBounds.minY - effectivePadding
-    ];
-    for (const newY of yCandidates) {
-      candidateDetours.push(
-        pB.x > pA.x ? [
-          { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
-          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-          { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y }
-        ] : [
-          { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
-          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-          { x: paddedLabelBounds.minX - effectivePadding, y: pB.y }
-        ]
-      );
-    }
-  }
-  return candidateDetours.map((detourPoints) => [
-    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
-    ...detourPoints,
-    ...initialTrace.tracePath.slice(collidingSegIndex + 1)
-  ]);
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts
-var generateRerouteCandidates = ({
-  trace,
-  label,
-  paddingBuffer,
-  detourCount
-}) => {
-  const initialTrace = { ...trace, tracePath: simplifyPath(trace.tracePath) };
-  if (trace.globalConnNetId === label.globalConnNetId) {
-    return [initialTrace.tracePath];
-  }
-  const labelPadding = paddingBuffer;
-  const labelBoundsRaw = getRectBounds(label.center, label.width, label.height);
-  const labelBounds = {
-    minX: labelBoundsRaw.minX - labelPadding,
-    minY: labelBoundsRaw.minY - labelPadding,
-    maxX: labelBoundsRaw.maxX + labelPadding,
-    maxY: labelBoundsRaw.maxY + labelPadding,
-    chipId: `netlabel-${label.netId}`
-  };
-  const fourPointCandidates = generateFourPointDetourCandidates({
-    initialTrace,
-    label,
-    labelBounds,
-    paddingBuffer,
-    detourCount
-  });
-  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
-    initialTrace.tracePath,
-    labelBounds
-  );
-  const snipReconnectCandidates = generateSnipAndReconnectCandidates({
-    initialTrace,
-    firstInsideIndex,
-    lastInsideIndex,
-    labelBounds,
-    paddingBuffer,
-    detourCount
-  });
-  return [...fourPointCandidates, ...snipReconnectCandidates];
+  const labelPadding = paddingBuffer;
+  const labelBoundsRaw = getRectBounds(label.center, label.width, label.height);
+  const labelBounds = {
+    minX: labelBoundsRaw.minX - labelPadding,
+    minY: labelBoundsRaw.minY - labelPadding,
+    maxX: labelBoundsRaw.maxX + labelPadding,
+    maxY: labelBoundsRaw.maxY + labelPadding,
+    chipId: `netlabel-${label.netId}`
+  };
+  const fourPointCandidates = generateFourPointDetourCandidates({
+    initialTrace,
+    label,
+    labelBounds,
+    paddingBuffer,
+    detourCount
+  });
+  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
+    initialTrace.tracePath,
+    labelBounds
+  );
+  const snipReconnectCandidates = generateSnipAndReconnectCandidates({
+    initialTrace,
+    firstInsideIndex,
+    lastInsideIndex,
+    labelBounds,
+    paddingBuffer,
+    detourCount
+  });
+  return [...fourPointCandidates, ...snipReconnectCandidates];
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
@@ -3272,7 +2788,6 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
   // sub-solver instances
   labelMergingSolver;
   overlapAvoidanceSolver;
-  traceCleanupSolver;
   pipelineStepIndex = 0;
   constructor(solverInput) {
     super();
@@ -3310,292 +2825,753 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
         });
         this.activeSubSolver = this.overlapAvoidanceSolver;
         break;
-      case 2:
-        this.traceCleanupSolver = new TraceCleanupSolver({
-          inputProblem: this.inputProblem,
-          allTraces: this.overlapAvoidanceSolver.getOutput().allTraces,
-          targetTraceIds: new Set(
-            this.overlapAvoidanceSolver.getOutput().modifiedTraces.map(
-              (t) => t.mspPairId
-            )
-          ),
-          allLabelPlacements: this.labelMergingSolver.getOutput().netLabelPlacements,
-          mergedLabelNetIdMap: this.labelMergingSolver.getOutput().mergedLabelNetIdMap,
-          paddingBuffer: 0.01
-        });
-        this.activeSubSolver = this.traceCleanupSolver;
-        break;
       default:
         this.solved = true;
         break;
     }
-  }
-  getOutput() {
-    return {
-      traces: this.traceCleanupSolver?.getOutput().traces ?? this.traces,
-      netLabelPlacements: this.labelMergingSolver?.getOutput().netLabelPlacements ?? this.netLabelPlacements
-    };
+  }
+  getOutput() {
+    return {
+      traces: this.overlapAvoidanceSolver?.getOutput().allTraces ?? this.traces,
+      netLabelPlacements: this.labelMergingSolver?.getOutput().netLabelPlacements ?? this.netLabelPlacements
+    };
+  }
+  visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
+    const graphics = visualizeInputProblem(this.inputProblem);
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.rects) graphics.rects = [];
+    const output = this.getOutput();
+    for (const trace of output.traces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const label of output.netLabelPlacements) {
+      const color = getColorFromString(label.globalConnNetId, 0.3);
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: color,
+        stroke: color.replace("0.3", "1"),
+        label: label.globalConnNetId
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts
+var correctPinsInsideChips = (problem) => {
+  for (const chip of problem.chips) {
+    const bounds = getInputChipBounds(chip);
+    for (const pin of chip.pins) {
+      const isInside = pin.x > bounds.minX && pin.x < bounds.maxX && pin.y > bounds.minY && pin.y < bounds.maxY;
+      if (!isInside) continue;
+      const distLeft = pin.x - bounds.minX;
+      const distRight = bounds.maxX - pin.x;
+      const distBottom = pin.y - bounds.minY;
+      const distTop = bounds.maxY - pin.y;
+      const minDist = Math.min(distLeft, distRight, distBottom, distTop);
+      if (minDist === distLeft) {
+        pin.x = bounds.minX;
+      } else if (minDist === distRight) {
+        pin.x = bounds.maxX;
+      } else if (minDist === distBottom) {
+        pin.y = bounds.minY;
+      } else {
+        pin.y = bounds.maxY;
+      }
+      pin._facingDirection = void 0;
+    }
+  }
+};
+
+// lib/solvers/SchematicTracePipelineSolver/expandChipsToFitPins.ts
+var expandChipsToFitPins = (problem) => {
+  for (const chip of problem.chips) {
+    const halfWidth = chip.width / 2;
+    const halfHeight = chip.height / 2;
+    let maxDx = 0;
+    let maxDy = 0;
+    for (const pin of chip.pins) {
+      const dx = Math.abs(pin.x - chip.center.x);
+      const dy = Math.abs(pin.y - chip.center.y);
+      if (dx > maxDx) maxDx = dx;
+      if (dy > maxDy) maxDy = dy;
+    }
+    const newHalfWidth = Math.max(halfWidth, maxDx);
+    const newHalfHeight = Math.max(halfHeight, maxDy);
+    if (newHalfWidth > halfWidth || newHalfHeight > halfHeight) {
+      chip.width = newHalfWidth * 2;
+      chip.height = newHalfHeight * 2;
+      for (const pin of chip.pins) {
+        pin._facingDirection = void 0;
+      }
+    }
+  }
+};
+
+// lib/utils/does-trace-overlap-with-existing-traces.ts
+import { doSegmentsIntersect } from "@tscircuit/math-utils";
+function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
+  for (let i = 0; i < newTracePath.length - 1; i++) {
+    const newSegmentP1 = newTracePath[i];
+    const newSegmentP2 = newTracePath[i + 1];
+    for (const existingTrace of existingTraces) {
+      for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
+        const existingSegmentP1 = existingTrace.tracePath[j];
+        const existingSegmentP2 = existingTrace.tracePath[j + 1];
+        if (doSegmentsIntersect(
+          newSegmentP1,
+          newSegmentP2,
+          existingSegmentP1,
+          existingSegmentP2
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
+var NEAREST_NEIGHBOR_COUNT = 3;
+var distance = (p1, p2) => {
+  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+};
+var LongDistancePairSolver = class extends BaseSolver {
+  constructor(params) {
+    super();
+    this.params = params;
+    const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } = this.params;
+    this.inputProblem = inputProblem;
+    this.allSolvedTraces = [...alreadySolvedTraces];
+    const primaryConnectedPinIds = /* @__PURE__ */ new Set();
+    for (const pair of primaryMspConnectionPairs) {
+      primaryConnectedPinIds.add(pair.pins[0].pinId);
+      primaryConnectedPinIds.add(pair.pins[1].pinId);
+    }
+    const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+    this.netConnMap = netConnMap;
+    const pinMap = /* @__PURE__ */ new Map();
+    for (const chip of inputProblem.chips) {
+      this.chipMap[chip.chipId] = chip;
+      for (const pin of chip.pins) {
+        pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
+      }
+    }
+    const candidatePairs = [];
+    const addedPairKeys = /* @__PURE__ */ new Set();
+    for (const netId of Object.keys(netConnMap.netMap)) {
+      const allPinIdsInNet = netConnMap.getIdsConnectedToNet(netId);
+      if (allPinIdsInNet.length < 2) continue;
+      const unconnectedPinIds = allPinIdsInNet.filter(
+        (pinId) => !primaryConnectedPinIds.has(pinId)
+      );
+      for (const unconnectedPinId of unconnectedPinIds) {
+        const sourcePin = pinMap.get(unconnectedPinId);
+        if (!sourcePin) continue;
+        const neighbors = allPinIdsInNet.filter((otherPinId) => otherPinId !== unconnectedPinId).flatMap((otherPinId) => {
+          const targetPin = pinMap.get(otherPinId);
+          if (!targetPin) return [];
+          return [
+            {
+              pin: targetPin,
+              distance: distance(sourcePin, targetPin)
+            }
+          ];
+        }).sort((a, b) => a.distance - b.distance).slice(0, NEAREST_NEIGHBOR_COUNT);
+        for (const neighbor of neighbors) {
+          const pair = [sourcePin, neighbor.pin];
+          const pairKey = pair.map((p) => p.pinId).sort().join("--");
+          if (!addedPairKeys.has(pairKey)) {
+            candidatePairs.push(pair);
+            addedPairKeys.add(pairKey);
+          }
+        }
+      }
+    }
+    this.queuedCandidatePairs = candidatePairs;
+  }
+  solvedLongDistanceTraces = [];
+  queuedCandidatePairs = [];
+  currentCandidatePair = null;
+  subSolver = null;
+  chipMap = {};
+  inputProblem;
+  netConnMap;
+  newlyConnectedPinIds = /* @__PURE__ */ new Set();
+  allSolvedTraces = [];
+  getConstructorParams() {
+    return this.params;
+  }
+  _step() {
+    if (this.subSolver?.solved) {
+      const newTracePath = this.subSolver.solvedTracePath;
+      if (newTracePath && this.currentCandidatePair) {
+        const isTraceClear = !doesTraceOverlapWithExistingTraces(
+          newTracePath,
+          this.allSolvedTraces
+        );
+        if (isTraceClear) {
+          const [p1, p2] = this.currentCandidatePair;
+          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId);
+          const mspPairId = `${p1.pinId}-${p2.pinId}`;
+          const newSolvedTrace = {
+            mspPairId,
+            dcConnNetId: globalConnNetId,
+            globalConnNetId,
+            pins: [p1, p2],
+            tracePath: newTracePath,
+            mspConnectionPairIds: [mspPairId],
+            pinIds: [p1.pinId, p2.pinId]
+          };
+          this.solvedLongDistanceTraces.push(newSolvedTrace);
+          this.allSolvedTraces.push(newSolvedTrace);
+          this.newlyConnectedPinIds.add(p1.pinId);
+          this.newlyConnectedPinIds.add(p2.pinId);
+        }
+      }
+      this.subSolver = null;
+      this.currentCandidatePair = null;
+    } else if (this.subSolver?.failed) {
+      this.subSolver = null;
+      this.currentCandidatePair = null;
+    }
+    if (this.subSolver) {
+      this.subSolver.step();
+      return;
+    }
+    while (this.queuedCandidatePairs.length > 0) {
+      const nextPair = this.queuedCandidatePairs.shift();
+      const [p1, p2] = nextPair;
+      if (this.newlyConnectedPinIds.has(p1.pinId) || this.newlyConnectedPinIds.has(p2.pinId)) {
+        continue;
+      }
+      this.currentCandidatePair = nextPair;
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: this.currentCandidatePair,
+        chipMap: this.chipMap
+      });
+      return;
+    }
+    this.solved = true;
   }
   visualize() {
-    if (this.activeSubSolver) {
-      return this.activeSubSolver.visualize();
+    if (this.subSolver) {
+      return this.subSolver.visualize();
     }
     const graphics = visualizeInputProblem(this.inputProblem);
-    if (!graphics.lines) graphics.lines = [];
-    if (!graphics.rects) graphics.rects = [];
-    const output = this.getOutput();
-    for (const trace of output.traces) {
+    for (const trace of this.solvedLongDistanceTraces) {
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "purple"
       });
     }
-    for (const label of output.netLabelPlacements) {
-      const color = getColorFromString(label.globalConnNetId, 0.3);
-      graphics.rects.push({
-        center: label.center,
-        width: label.width,
-        height: label.height,
-        fill: color,
-        stroke: color.replace("0.3", "1"),
-        label: label.globalConnNetId
+    for (const [p1, p2] of this.queuedCandidatePairs) {
+      graphics.lines.push({
+        points: [p1, p2],
+        strokeColor: "gray",
+        strokeDash: "4 4"
       });
     }
     return graphics;
   }
+  getOutput() {
+    if (!this.solved) {
+      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces };
+    }
+    return {
+      newTraces: this.solvedLongDistanceTraces,
+      allTracesMerged: [
+        ...this.params.alreadySolvedTraces,
+        ...this.solvedLongDistanceTraces
+      ]
+    };
+  }
 };
 
-// lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts
-var correctPinsInsideChips = (problem) => {
-  for (const chip of problem.chips) {
-    const bounds = getInputChipBounds(chip);
-    for (const pin of chip.pins) {
-      const isInside = pin.x > bounds.minX && pin.x < bounds.maxX && pin.y > bounds.minY && pin.y < bounds.maxY;
-      if (!isInside) continue;
-      const distLeft = pin.x - bounds.minX;
-      const distRight = bounds.maxX - pin.x;
-      const distBottom = pin.y - bounds.minY;
-      const distTop = bounds.maxY - pin.y;
-      const minDist = Math.min(distLeft, distRight, distBottom, distTop);
-      if (minDist === distLeft) {
-        pin.x = bounds.minX;
-      } else if (minDist === distRight) {
-        pin.x = bounds.maxX;
-      } else if (minDist === distBottom) {
-        pin.y = bounds.minY;
-      } else {
-        pin.y = bounds.maxY;
+// lib/solvers/TraceCleanupSolver/hasCollisions.ts
+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)) {
+        return true;
       }
-      pin._facingDirection = void 0;
     }
   }
+  return false;
 };
 
-// lib/solvers/SchematicTracePipelineSolver/expandChipsToFitPins.ts
-var expandChipsToFitPins = (problem) => {
-  for (const chip of problem.chips) {
-    const halfWidth = chip.width / 2;
-    const halfHeight = chip.height / 2;
-    let maxDx = 0;
-    let maxDy = 0;
-    for (const pin of chip.pins) {
-      const dx = Math.abs(pin.x - chip.center.x);
-      const dy = Math.abs(pin.y - chip.center.y);
-      if (dx > maxDx) maxDx = dx;
-      if (dy > maxDy) maxDy = dy;
+// lib/solvers/TraceCleanupSolver/countTurns.ts
+var countTurns = (points) => {
+  let turns = 0;
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    const next = points[i + 1];
+    const prevVertical = prev.x === curr.x;
+    const nextVertical = curr.x === next.x;
+    if (prevVertical !== nextVertical) {
+      turns++;
     }
-    const newHalfWidth = Math.max(halfWidth, maxDx);
-    const newHalfHeight = Math.max(halfHeight, maxDy);
-    if (newHalfWidth > halfWidth || newHalfHeight > halfHeight) {
-      chip.width = newHalfWidth * 2;
-      chip.height = newHalfHeight * 2;
-      for (const pin of chip.pins) {
-        pin._facingDirection = void 0;
+  }
+  return turns;
+};
+
+// lib/solvers/TraceCleanupSolver/tryConnectPoints.ts
+var tryConnectPoints = (start, end) => {
+  const candidates = [];
+  if (start.x === end.x || start.y === end.y) {
+    candidates.push([start, end]);
+  } else {
+    candidates.push([start, { x: end.x, y: start.y }, end]);
+    candidates.push([start, { x: start.x, y: end.y }, end]);
+  }
+  return candidates;
+};
+
+// lib/solvers/TraceCleanupSolver/hasCollisionsWithLabels.ts
+var hasCollisionsWithLabels = (pathSegments, labels) => {
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i];
+    const p2 = pathSegments[i + 1];
+    for (const label of labels) {
+      if (segmentIntersectsRect(p1, p2, label)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+// lib/solvers/TraceCleanupSolver/turnMinimization.ts
+var minimizeTurns = ({
+  path,
+  obstacles,
+  labelBounds
+}) => {
+  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;
+  while (improved) {
+    improved = false;
+    for (let startIdx = 0; startIdx < optimizedPath.length - 3; startIdx++) {
+      const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx);
+      if (stairEndIdx > 0) {
+        const startPoint = optimizedPath[startIdx];
+        const endPoint = optimizedPath[stairEndIdx];
+        const connectionOptions = tryConnectPoints(startPoint, endPoint);
+        for (const connection of connectionOptions) {
+          const testPath = [
+            ...optimizedPath.slice(0, startIdx + 1),
+            ...connection.slice(1, -1),
+            ...optimizedPath.slice(stairEndIdx)
+          ];
+          const collidesWithObstacles = hasCollisions(connection, obstacles);
+          const collidesWithLabels = hasCollisionsWithLabels(
+            connection,
+            labelBounds
+          );
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            const newTurns = countTurns(testPath);
+            optimizedPath = testPath;
+            currentTurns = newTurns;
+            improved = true;
+            break;
+          }
+        }
+        if (improved) break;
+      }
+    }
+    if (!improved) {
+      for (let startIdx = 0; startIdx < optimizedPath.length - 2; startIdx++) {
+        const maxRemove = Math.min(
+          optimizedPath.length - startIdx - 2,
+          optimizedPath.length - 2
+        );
+        for (let removeCount = 1; removeCount <= maxRemove; removeCount++) {
+          const endIdx = startIdx + removeCount + 1;
+          if (endIdx >= optimizedPath.length) continue;
+          const startPoint = optimizedPath[startIdx];
+          const endPoint = optimizedPath[endIdx];
+          const connectionOptions = tryConnectPoints(startPoint, endPoint);
+          for (const connection of connectionOptions) {
+            const testPath = [
+              ...optimizedPath.slice(0, startIdx + 1),
+              ...connection.slice(1, -1),
+              ...optimizedPath.slice(endIdx)
+            ];
+            const connectionSegments = connection;
+            const collidesWithObstacles = hasCollisions(
+              connectionSegments,
+              obstacles
+            );
+            const collidesWithLabels = hasCollisionsWithLabels(
+              connectionSegments,
+              labelBounds
+            );
+            if (!collidesWithObstacles && !collidesWithLabels) {
+              const newTurns = countTurns(testPath);
+              if (newTurns < currentTurns || newTurns === currentTurns && testPath.length < optimizedPath.length) {
+                optimizedPath = testPath;
+                currentTurns = newTurns;
+                improved = true;
+                break;
+              }
+            }
+          }
+          if (improved) break;
+        }
+        if (improved) break;
+      }
+    }
+    if (!improved) {
+      for (let i = 0; i < optimizedPath.length - 2; i++) {
+        const p1 = optimizedPath[i];
+        const p2 = optimizedPath[i + 1];
+        const p3 = optimizedPath[i + 2];
+        const allVertical = p1.x === p2.x && p2.x === p3.x;
+        const allHorizontal = p1.y === p2.y && p2.y === p3.y;
+        if (allVertical || allHorizontal) {
+          const testPath = [
+            ...optimizedPath.slice(0, i + 1),
+            ...optimizedPath.slice(i + 2)
+          ];
+          const collidesWithObstacles = hasCollisions([p1, p3], obstacles);
+          const collidesWithLabels = hasCollisionsWithLabels(
+            [p1, p3],
+            labelBounds
+          );
+          if (!collidesWithObstacles && !collidesWithLabels) {
+            optimizedPath = testPath;
+            improved = true;
+            break;
+          }
+        }
       }
     }
   }
+  const finalSimplifiedPath = simplifyPath(optimizedPath);
+  return finalSimplifiedPath;
 };
 
-// lib/utils/does-trace-overlap-with-existing-traces.ts
-import { doSegmentsIntersect } from "@tscircuit/math-utils";
-function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
-  for (let i = 0; i < newTracePath.length - 1; i++) {
-    const newSegmentP1 = newTracePath[i];
-    const newSegmentP2 = newTracePath[i + 1];
-    for (const existingTrace of existingTraces) {
-      for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
-        const existingSegmentP1 = existingTrace.tracePath[j];
-        const existingSegmentP2 = existingTrace.tracePath[j + 1];
-        if (doSegmentsIntersect(
-          newSegmentP1,
-          newSegmentP2,
-          existingSegmentP1,
-          existingSegmentP2
-        )) {
-          return true;
-        }
-      }
-    }
+// lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts
+var minimizeTurnsWithFilteredLabels = ({
+  targetMspConnectionPairId,
+  traces,
+  inputProblem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer
+}) => {
+  const targetTrace = traces.find(
+    (t) => t.mspPairId === targetMspConnectionPairId
+  );
+  if (!targetTrace) {
+    throw new Error(`Target trace ${targetMspConnectionPairId} not found`);
   }
-  return false;
-}
-
-// lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
-var NEAREST_NEIGHBOR_COUNT = 3;
-var distance = (p1, p2) => {
-  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+  const obstacleTraces = traces.filter(
+    (t) => t.mspPairId !== targetMspConnectionPairId
+  );
+  const TRACE_WIDTH = 0.01;
+  const traceObstacles = obstacleTraces.flatMap(
+    (trace, i) => trace.tracePath.slice(0, -1).map((p1, pi) => {
+      const p2 = trace.tracePath[pi + 1];
+      return {
+        chipId: `trace-obstacle-${i}-${pi}`,
+        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2
+      };
+    })
+  );
+  const staticObstacles = getObstacleRects(inputProblem);
+  const combinedObstacles = [...staticObstacles, ...traceObstacles];
+  const originalPath = targetTrace.tracePath;
+  const filteredLabels = allLabelPlacements.filter((label) => {
+    const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
+    if (originalNetIds) {
+      return !originalNetIds.has(targetTrace.globalConnNetId);
+    }
+    return label.globalConnNetId !== targetTrace.globalConnNetId;
+  });
+  const labelBounds = filteredLabels.map((nl) => ({
+    minX: nl.center.x - nl.width / 2 - paddingBuffer,
+    maxX: nl.center.x + nl.width / 2 + paddingBuffer,
+    minY: nl.center.y - nl.height / 2 - paddingBuffer,
+    maxY: nl.center.y + nl.height / 2 + paddingBuffer
+  }));
+  const newPath = minimizeTurns({
+    path: originalPath,
+    obstacles: combinedObstacles,
+    labelBounds
+  });
+  return {
+    ...targetTrace,
+    tracePath: newPath
+  };
 };
-var LongDistancePairSolver = class extends BaseSolver {
-  constructor(params) {
-    super();
-    this.params = params;
-    const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } = this.params;
-    this.inputProblem = inputProblem;
-    this.allSolvedTraces = [...alreadySolvedTraces];
-    const primaryConnectedPinIds = /* @__PURE__ */ new Set();
-    for (const pair of primaryMspConnectionPairs) {
-      primaryConnectedPinIds.add(pair.pins[0].pinId);
-      primaryConnectedPinIds.add(pair.pins[1].pinId);
-    }
-    const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
-    this.netConnMap = netConnMap;
-    const pinMap = /* @__PURE__ */ new Map();
-    for (const chip of inputProblem.chips) {
-      this.chipMap[chip.chipId] = chip;
-      for (const pin of chip.pins) {
-        pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
+
+// lib/solvers/TraceCleanupSolver/balanceZShapes.ts
+var balanceZShapes = ({
+  targetMspConnectionPairId,
+  traces,
+  inputProblem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer
+}) => {
+  const targetTrace = traces.find(
+    (t) => t.mspPairId === targetMspConnectionPairId
+  );
+  if (!targetTrace) {
+    throw new Error(`Target trace ${targetMspConnectionPairId} not found`);
+  }
+  const TOLERANCE = 1e-5;
+  const obstacleTraces = traces.filter(
+    (t) => t.mspPairId !== targetMspConnectionPairId
+  );
+  const TRACE_WIDTH = 0.01;
+  const traceObstacles = obstacleTraces.flatMap(
+    (trace, i) => trace.tracePath.slice(0, -1).map((p1, pi) => {
+      const p2 = trace.tracePath[pi + 1];
+      return {
+        chipId: `trace-obstacle-${i}-${pi}`,
+        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2
+      };
+    })
+  );
+  const staticObstacles = getObstacleRects(inputProblem).map((obs) => ({
+    ...obs,
+    minX: obs.minX + TOLERANCE,
+    maxX: obs.maxX - TOLERANCE,
+    minY: obs.minY + TOLERANCE,
+    maxY: obs.maxY - TOLERANCE
+  }));
+  const combinedObstacles = [...staticObstacles, ...traceObstacles];
+  const segmentIntersectsAnyRect = (p1, p2, rects) => {
+    for (const rect of rects) {
+      if (segmentIntersectsRect(p1, p2, rect)) {
+        return true;
       }
     }
-    const candidatePairs = [];
-    const addedPairKeys = /* @__PURE__ */ new Set();
-    for (const netId of Object.keys(netConnMap.netMap)) {
-      const allPinIdsInNet = netConnMap.getIdsConnectedToNet(netId);
-      if (allPinIdsInNet.length < 2) continue;
-      const unconnectedPinIds = allPinIdsInNet.filter(
-        (pinId) => !primaryConnectedPinIds.has(pinId)
-      );
-      for (const unconnectedPinId of unconnectedPinIds) {
-        const sourcePin = pinMap.get(unconnectedPinId);
-        if (!sourcePin) continue;
-        const neighbors = allPinIdsInNet.filter((otherPinId) => otherPinId !== unconnectedPinId).flatMap((otherPinId) => {
-          const targetPin = pinMap.get(otherPinId);
-          if (!targetPin) return [];
-          return [
-            {
-              pin: targetPin,
-              distance: distance(sourcePin, targetPin)
-            }
-          ];
-        }).sort((a, b) => a.distance - b.distance).slice(0, NEAREST_NEIGHBOR_COUNT);
-        for (const neighbor of neighbors) {
-          const pair = [sourcePin, neighbor.pin];
-          const pairKey = pair.map((p) => p.pinId).sort().join("--");
-          if (!addedPairKeys.has(pairKey)) {
-            candidatePairs.push(pair);
-            addedPairKeys.add(pairKey);
-          }
-        }
-      }
+    return false;
+  };
+  const filteredLabels = allLabelPlacements.filter((label) => {
+    const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
+    if (originalNetIds) {
+      return !originalNetIds.has(targetTrace.globalConnNetId);
+    }
+    return label.globalConnNetId !== targetTrace.globalConnNetId;
+  });
+  const labelBounds = filteredLabels.map((nl) => ({
+    minX: nl.center.x - nl.width / 2 + TOLERANCE,
+    maxX: nl.center.x + nl.width / 2 - TOLERANCE,
+    minY: nl.center.y - nl.height / 2 + TOLERANCE,
+    maxY: nl.center.y + nl.height / 2 - TOLERANCE
+  }));
+  const newPath = [...targetTrace.tracePath];
+  if (newPath.length < 4) {
+    return { ...targetTrace };
+  }
+  if (newPath.length === 4) {
+    const [p0, p1, p2, p3] = newPath;
+    let p1New;
+    let p2New;
+    const isHVHShape = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y;
+    if (isHVHShape) {
+      const idealX = (p0.x + p3.x) / 2;
+      p1New = { x: idealX, y: p1.y };
+      p2New = { x: idealX, y: p2.y };
+    } else {
+      const idealY = (p0.y + p3.y) / 2;
+      p1New = { x: p1.x, y: idealY };
+      p2New = { x: p2.x, y: idealY };
+    }
+    const collides = segmentIntersectsAnyRect(p0, p1New, combinedObstacles) || segmentIntersectsAnyRect(p1New, p2New, combinedObstacles) || segmentIntersectsAnyRect(p2New, p3, combinedObstacles) || segmentIntersectsAnyRect(p0, p1New, labelBounds) || segmentIntersectsAnyRect(p1New, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3, labelBounds);
+    if (!collides) {
+      newPath[1] = p1New;
+      newPath[2] = p2New;
+    }
+    return { ...targetTrace, tracePath: simplifyPath(newPath) };
+  }
+  for (let i = 1; i < newPath.length - 4; i++) {
+    const p1 = newPath[i];
+    const p2 = newPath[i + 1];
+    const p3 = newPath[i + 2];
+    const p4 = newPath[i + 3];
+    const isHVHZShape = p1.y === p2.y && p2.x === p3.x && p3.y === p4.y;
+    const isVHVZShape = p1.x === p2.x && p2.y === p3.y && p3.x === p4.x;
+    const isCollinearHorizontal = p1.y === p2.y && p2.y === p3.y && p3.y === p4.y;
+    const isCollinearVertical = p1.x === p2.x && p2.x === p3.x && p3.x === p4.x;
+    const isCollinear = isCollinearHorizontal || isCollinearVertical;
+    let isSameDirection = false;
+    if (isHVHZShape) {
+      isSameDirection = Math.sign(p2.x - p1.x) === Math.sign(p4.x - p3.x);
+    } else if (isVHVZShape) {
+      isSameDirection = Math.sign(p2.y - p1.y) === Math.sign(p4.y - p3.y);
+    }
+    const isValidZShape = (isHVHZShape || isVHVZShape) && !isCollinear && isSameDirection;
+    if (!isValidZShape) {
+      continue;
+    }
+    let p2New;
+    let p3New;
+    const len1Original = isHVHZShape ? Math.abs(p1.x - p2.x) : Math.abs(p1.y - p2.y);
+    const len2Original = isHVHZShape ? Math.abs(p3.x - p4.x) : Math.abs(p3.y - p4.y);
+    if (Math.abs(len1Original - len2Original) < 1e-3) {
+      continue;
+    }
+    if (isHVHZShape) {
+      const idealX = (p1.x + p4.x) / 2;
+      p2New = { x: idealX, y: p2.y };
+      p3New = { x: idealX, y: p3.y };
+    } else {
+      const idealY = (p1.y + p4.y) / 2;
+      p2New = { x: p2.x, y: idealY };
+      p3New = { x: p3.x, y: idealY };
+    }
+    const collides = segmentIntersectsAnyRect(p1, p2New, combinedObstacles) || segmentIntersectsAnyRect(p2New, p3New, combinedObstacles) || segmentIntersectsAnyRect(p3New, p4, combinedObstacles) || segmentIntersectsAnyRect(p1, p2New, labelBounds) || segmentIntersectsAnyRect(p2New, p3New, labelBounds) || segmentIntersectsAnyRect(p3New, p4, labelBounds);
+    if (!collides) {
+      newPath[i + 1] = p2New;
+      newPath[i + 2] = p3New;
+      i = 0;
     }
-    this.queuedCandidatePairs = candidatePairs;
   }
-  solvedLongDistanceTraces = [];
-  queuedCandidatePairs = [];
-  currentCandidatePair = null;
-  subSolver = null;
-  chipMap = {};
-  inputProblem;
-  netConnMap;
-  newlyConnectedPinIds = /* @__PURE__ */ new Set();
-  allSolvedTraces = [];
-  getConstructorParams() {
-    return this.params;
+  const finalSimplifiedPath = simplifyPath(newPath);
+  return {
+    ...targetTrace,
+    tracePath: finalSimplifiedPath
+  };
+};
+
+// lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts
+var TraceCleanupSolver = class extends BaseSolver {
+  input;
+  outputTraces;
+  traceIdQueue;
+  tracesMap;
+  pipelineStep = "minimizing_turns";
+  activeTraceId = null;
+  // New property
+  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);
   }
   _step() {
-    if (this.subSolver?.solved) {
-      const newTracePath = this.subSolver.solvedTracePath;
-      if (newTracePath && this.currentCandidatePair) {
-        const isTraceClear = !doesTraceOverlapWithExistingTraces(
-          newTracePath,
-          this.allSolvedTraces
-        );
-        if (isTraceClear) {
-          const [p1, p2] = this.currentCandidatePair;
-          const globalConnNetId = this.netConnMap.getNetConnectedToId(p1.pinId);
-          const mspPairId = `${p1.pinId}-${p2.pinId}`;
-          const newSolvedTrace = {
-            mspPairId,
-            dcConnNetId: globalConnNetId,
-            globalConnNetId,
-            pins: [p1, p2],
-            tracePath: newTracePath,
-            mspConnectionPairIds: [mspPairId],
-            pinIds: [p1.pinId, p2.pinId]
-          };
-          this.solvedLongDistanceTraces.push(newSolvedTrace);
-          this.allSolvedTraces.push(newSolvedTrace);
-          this.newlyConnectedPinIds.add(p1.pinId);
-          this.newlyConnectedPinIds.add(p2.pinId);
-        }
-      }
-      this.subSolver = null;
-      this.currentCandidatePair = null;
-    } else if (this.subSolver?.failed) {
-      this.subSolver = null;
-      this.currentCandidatePair = null;
+    if (this.pipelineStep === "minimizing_turns" && this.traceIdQueue.length === 0) {
+      this.pipelineStep = "balancing_l_shapes";
+      this.traceIdQueue = Array.from(this.input.targetTraceIds);
     }
-    if (this.subSolver) {
-      this.subSolver.step();
+    if (this.pipelineStep === "balancing_l_shapes" && this.traceIdQueue.length === 0) {
+      this.solved = true;
       return;
     }
-    while (this.queuedCandidatePairs.length > 0) {
-      const nextPair = this.queuedCandidatePairs.shift();
-      const [p1, p2] = nextPair;
-      if (this.newlyConnectedPinIds.has(p1.pinId) || this.newlyConnectedPinIds.has(p2.pinId)) {
-        continue;
-      }
-      this.currentCandidatePair = nextPair;
-      this.subSolver = new SchematicTraceSingleLineSolver2({
-        inputProblem: this.params.inputProblem,
-        pins: this.currentCandidatePair,
-        chipMap: this.chipMap
-      });
+    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)) {
       return;
     }
-    this.solved = true;
-  }
-  visualize() {
-    if (this.subSolver) {
-      return this.subSolver.visualize();
-    }
-    const graphics = visualizeInputProblem(this.inputProblem);
-    for (const trace of this.solvedLongDistanceTraces) {
-      graphics.lines.push({
-        points: trace.tracePath,
-        strokeColor: "purple"
+    const allTraces = Array.from(this.tracesMap.values());
+    let updatedTrace;
+    if (this.pipelineStep === "minimizing_turns") {
+      updatedTrace = minimizeTurnsWithFilteredLabels({
+        ...this.input,
+        targetMspConnectionPairId,
+        traces: allTraces
       });
-    }
-    for (const [p1, p2] of this.queuedCandidatePairs) {
-      graphics.lines.push({
-        points: [p1, p2],
-        strokeColor: "gray",
-        strokeDash: "4 4"
+    } else {
+      updatedTrace = balanceZShapes({
+        ...this.input,
+        targetMspConnectionPairId,
+        traces: allTraces
       });
     }
-    return graphics;
+    this.tracesMap.set(targetMspConnectionPairId, updatedTrace);
+    this.outputTraces = Array.from(this.tracesMap.values());
   }
   getOutput() {
-    if (!this.solved) {
-      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces };
-    }
     return {
-      newTraces: this.solvedLongDistanceTraces,
-      allTracesMerged: [
-        ...this.params.alreadySolvedTraces,
-        ...this.solvedLongDistanceTraces
-      ]
+      traces: this.outputTraces
     };
   }
+  visualize() {
+    const graphics = visualizeInputProblem(this.input.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1
+    });
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.points) graphics.points = [];
+    if (!graphics.rects) graphics.rects = [];
+    if (!graphics.circles) graphics.circles = [];
+    if (!graphics.texts) graphics.texts = [];
+    for (const trace of this.outputTraces) {
+      const line = {
+        points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
+        strokeColor: trace.mspPairId === this.activeTraceId ? "red" : "blue"
+        // Highlight active trace
+      };
+      graphics.lines.push(line);
+    }
+    return graphics;
+  }
 };
 
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
@@ -3725,6 +3701,21 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         ];
       }
     ),
+    definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
+      const prevSolverOutput = instance.traceLabelOverlapAvoidanceSolver.getOutput();
+      const traces = prevSolverOutput.traces;
+      const labelMergingOutput = instance.traceLabelOverlapAvoidanceSolver.labelMergingSolver.getOutput();
+      return [
+        {
+          inputProblem: instance.inputProblem,
+          allTraces: traces,
+          targetTraceIds: new Set(traces.map((t) => t.mspPairId)),
+          allLabelPlacements: labelMergingOutput.netLabelPlacements,
+          mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
+          paddingBuffer: 0.1
+        }
+      ];
+    }),
     definePipelineStep(
       "netLabelPlacementSolver",
       NetLabelPlacementSolver,