@tscircuit/schematic-trace-solver 0.0.40 → 0.0.42

package/dist/index.js

@@ -2196,48 +2196,193 @@ var NetLabelPlacementSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/GuidelinesSolver/GuidelinesSolver.ts
-import { getBounds as getBounds3 } from "graphics-debug";
-
-// 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;
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver.ts
+var MergedNetLabelObstacleSolver = class extends BaseSolver {
+  input;
+  output;
+  inputProblem;
+  traces;
+  constructor(solverInput) {
+    super();
+    this.input = solverInput;
+    this.inputProblem = solverInput.inputProblem;
+    this.traces = solverInput.traces;
+    this.output = {
+      netLabelPlacements: solverInput.netLabelPlacements,
+      mergedLabelNetIdMap: {}
+    };
+  }
+  _step() {
+    const originalLabels = this.input.netLabelPlacements;
+    const mergedLabelNetIdMap = {};
+    if (!originalLabels || originalLabels.length === 0) {
+      this.output = {
+        netLabelPlacements: [],
+        mergedLabelNetIdMap: {}
+      };
+      this.solved = true;
+      return;
+    }
+    const labelGroups = {};
+    for (const p of originalLabels) {
+      if (p.pinIds.length === 0) continue;
+      const chipId = p.pinIds[0].split(".")[0];
+      if (!chipId) continue;
+      const key = `${chipId}-${p.orientation}`;
+      if (!(key in labelGroups)) {
+        labelGroups[key] = [];
+      }
+      labelGroups[key].push(p);
+    }
+    const finalPlacements = [];
+    for (const [key, group] of Object.entries(labelGroups)) {
+      if (group.length <= 1) {
+        finalPlacements.push(...group);
+        continue;
+      }
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const p of group) {
+        const bounds = getRectBounds(p.center, p.width, p.height);
+        minX = Math.min(minX, bounds.minX);
+        minY = Math.min(minY, bounds.minY);
+        maxX = Math.max(maxX, bounds.maxX);
+        maxY = Math.max(maxY, bounds.maxY);
+      }
+      const newWidth = maxX - minX;
+      const newHeight = maxY - minY;
+      const template = group[0];
+      const syntheticId = `merged-group-${key}`;
+      const originalNetIds = new Set(group.map((p) => p.globalConnNetId));
+      mergedLabelNetIdMap[syntheticId] = originalNetIds;
+      finalPlacements.push({
+        ...template,
+        globalConnNetId: syntheticId,
+        width: newWidth,
+        height: newHeight,
+        center: { x: minX + newWidth / 2, y: minY + newHeight / 2 },
+        pinIds: [...new Set(group.flatMap((p) => p.pinIds))],
+        mspConnectionPairIds: [
+          ...new Set(group.flatMap((p) => p.mspConnectionPairIds))
+        ]
+      });
+    }
+    this.output = {
+      netLabelPlacements: finalPlacements,
+      mergedLabelNetIdMap
+    };
+    this.solved = true;
+  }
+  getOutput() {
+    return this.output;
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1
+    });
+    if (!graphics.rects) graphics.rects = [];
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.points) graphics.points = [];
+    if (!graphics.texts) graphics.texts = [];
+    const originalLabelsById = /* @__PURE__ */ new Map();
+    for (const label of this.input.netLabelPlacements) {
+      originalLabelsById.set(label.globalConnNetId, label);
+    }
+    for (const trace of this.traces) {
+      const line = {
+        points: trace.tracePath.map((p) => ({ x: p.x, y: p.y })),
+        strokeColor: "blue"
+      };
+      graphics.lines.push(line);
+    }
+    for (const finalLabel of this.output.netLabelPlacements) {
+      const isMerged = finalLabel.globalConnNetId.startsWith("merged-group-");
+      const color = getColorFromString(finalLabel.globalConnNetId);
+      if (isMerged) {
+        graphics.rects.push({
+          center: finalLabel.center,
+          width: finalLabel.width,
+          height: finalLabel.height,
+          fill: color.replace(/, 1\)/, ", 0.2)"),
+          // semi-transparent
+          stroke: color,
+          label: finalLabel.globalConnNetId
+        });
+        const originalNetIds = this.output.mergedLabelNetIdMap[finalLabel.globalConnNetId];
+        if (originalNetIds) {
+          for (const originalNetId of originalNetIds) {
+            const originalLabel = originalLabelsById.get(originalNetId);
+            if (originalLabel) {
+              const bounds = getRectBounds(
+                originalLabel.center,
+                originalLabel.width,
+                originalLabel.height
+              );
+              const p1 = { x: bounds.minX, y: bounds.minY };
+              const p2 = { x: bounds.maxX, y: bounds.minY };
+              const p3 = { x: bounds.maxX, y: bounds.maxY };
+              const p4 = { x: bounds.minX, y: bounds.maxY };
+              graphics.lines.push({
+                points: [p1, p2, p3, p4, p1],
+                strokeColor: color,
+                strokeDash: "4 4"
+              });
+              graphics.lines.push({
+                points: [originalLabel.center, finalLabel.center],
+                strokeColor: color,
+                strokeDash: "2 2"
+              });
+            }
           }
-          overlaps.push({ trace, label });
-          break;
         }
+      } else {
+        graphics.rects.push({
+          center: finalLabel.center,
+          width: finalLabel.width,
+          height: finalLabel.height,
+          stroke: color,
+          label: finalLabel.globalConnNetId
+        });
       }
     }
+    return graphics;
   }
-  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;
+// 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;
       }
-      lastInsideIndex = i;
     }
   }
-  return { firstInsideIndex, lastInsideIndex };
+  return false;
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/simplifyPath.ts
+// 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++;
+    }
+  }
+  return turns;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/simplifyPath.ts
 var simplifyPath = (path) => {
   if (path.length < 3) return path;
   const newPath = [path[0]];
@@ -2266,282 +2411,40 @@ var simplifyPath = (path) => {
   return finalPath;
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts
-var trySnipAndReconnect = ({
-  initialTrace,
-  firstInsideIndex,
-  lastInsideIndex,
-  labelBounds,
-  obstacles
-}) => {
-  if (firstInsideIndex <= 0 || lastInsideIndex >= initialTrace.tracePath.length - 1) {
-    return null;
-  }
-  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 candidateDetours = [];
-  if (entryPoint.x !== exitPoint.x && entryPoint.y !== exitPoint.y) {
-    candidateDetours.push([{ x: exitPoint.x, y: entryPoint.y }]);
-    candidateDetours.push([{ x: entryPoint.x, y: exitPoint.y }]);
-  } else if (entryPoint.x === exitPoint.x || entryPoint.y === exitPoint.y) {
-    const newPath = [...pathToEntry, ...pathFromExit];
-    const simplified = simplifyPath(newPath);
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified };
-    }
-  }
-  for (let i = 0; i < candidateDetours.length; i++) {
-    const detour = candidateDetours[i];
-    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit];
-    const simplified = simplifyPath(newFullPath);
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified };
-    }
-  }
-  candidateDetours.length = 0;
-  const buffer = 0.1;
-  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) {
-    candidateDetours.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) {
-    candidateDetours.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) {
-    candidateDetours.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) {
-    candidateDetours.push([
-      { x: entryPoint.x, y: bottomY },
-      { x: exitPoint.x, y: bottomY }
-    ]);
+// 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]);
   }
-  for (let i = 0; i < candidateDetours.length; i++) {
-    const detour = candidateDetours[i];
-    const newFullPath = [...pathToEntry, ...detour, ...pathFromExit];
-    const simplified = simplifyPath(newFullPath);
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified };
+  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;
+      }
     }
   }
-  return null;
+  return false;
 };
-var tryFourPointDetour = ({
-  initialTrace,
-  label,
-  labelBounds,
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/turnMinimization.ts
+var minimizeTurns = ({
+  path,
   obstacles,
-  paddingBuffer,
-  detourCount
+  labelBounds
 }) => {
-  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 initialTrace;
-  const pA = initialTrace.tracePath[collidingSegIndex];
-  const pB = initialTrace.tracePath[collidingSegIndex + 1];
-  if (!pA || !pB) return null;
-  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 }
-        ]
-      );
-    }
-  }
-  for (const detourPoints of candidateDetours) {
-    const finalPath = [
-      ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
-      ...detourPoints,
-      ...initialTrace.tracePath.slice(collidingSegIndex + 1)
-    ];
-    const simplifiedFinalPath = simplifyPath(finalPath);
-    if (!isPathCollidingWithObstacles(simplifiedFinalPath, obstacles)) {
-      return { ...initialTrace, tracePath: simplifiedFinalPath };
-    }
-  }
-  return null;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts
-var rerouteCollidingTrace = ({
-  trace,
-  label,
-  problem,
-  paddingBuffer,
-  detourCount
-}) => {
-  const initialTrace = { ...trace, tracePath: simplifyPath(trace.tracePath) };
-  if (trace.globalConnNetId === label.globalConnNetId) {
-    return initialTrace;
-  }
-  const obstacles = getObstacleRects(problem);
-  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 fourPointResult = tryFourPointDetour({
-    initialTrace,
-    label,
-    labelBounds,
-    obstacles,
-    paddingBuffer,
-    detourCount
-  });
-  if (fourPointResult) {
-    initialTrace.tracePath = fourPointResult.tracePath;
-  }
-  const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
-    initialTrace.tracePath,
-    labelBounds
-  );
-  const snipReconnectResult = trySnipAndReconnect({
-    initialTrace,
-    firstInsideIndex,
-    lastInsideIndex,
-    labelBounds,
-    obstacles
-  });
-  if (snipReconnectResult) {
-    return snipReconnectResult;
-  }
-  if (fourPointResult) {
-    return fourPointResult;
-  }
-  return initialTrace;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/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;
-      }
-    }
-  }
-  return false;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/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++;
-    }
-  }
-  return turns;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/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/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/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts
-var minimizeTurns = ({
-  path,
-  obstacles,
-  labelBounds
-}) => {
-  if (path.length <= 2) {
-    return path;
+  if (path.length <= 2) {
+    return path;
   }
   const recognizeStairStepPattern = (pathToCheck, startIdx) => {
     if (startIdx >= pathToCheck.length - 3) return -1;
@@ -2595,7 +2498,6 @@ var minimizeTurns = ({
           );
           if (!collidesWithObstacles && !collidesWithLabels) {
             const newTurns = countTurns(testPath);
-            const turnsRemoved = stairEndIdx - startIdx - 1;
             optimizedPath = testPath;
             currentTurns = newTurns;
             improved = true;
@@ -2677,16 +2579,16 @@ var minimizeTurns = ({
   return finalSimplifiedPath;
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/minimizeTurnsWithFilteredLabels.ts
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts
 var minimizeTurnsWithFilteredLabels = ({
   traces,
-  problem,
+  inputProblem,
   allLabelPlacements,
   mergedLabelNetIdMap,
   paddingBuffer
 }) => {
   let changesMade = false;
-  const obstacles = getObstacleRects(problem);
+  const obstacles = getObstacleRects(inputProblem);
   const newTraces = traces.map((trace) => {
     const originalPath = trace.tracePath;
     const filteredLabels = allLabelPlacements.filter((label) => {
@@ -2724,10 +2626,10 @@ var minimizeTurnsWithFilteredLabels = ({
   }
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/balanceLShapes.ts
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/TraceCleanupSolver/balanceLShapes.ts
 var balanceLShapes = ({
   traces,
-  problem,
+  inputProblem,
   allLabelPlacements
 }) => {
   const TOLERANCE = 1e-5;
@@ -2752,7 +2654,7 @@ var balanceLShapes = ({
       }
     }
   }
-  const obstacles = getObstacleRects(problem).map((obs) => ({
+  const obstacles = getObstacleRects(inputProblem).map((obs) => ({
     ...obs,
     minX: obs.minX + TOLERANCE,
     maxX: obs.maxX - TOLERANCE,
@@ -2779,7 +2681,7 @@ var balanceLShapes = ({
     }));
   };
   const newTraces = traces.map((trace) => {
-    let newPath = [...trace.tracePath];
+    const newPath = [...trace.tracePath];
     if (newPath.length < 4) {
       return { ...trace };
     }
@@ -2789,7 +2691,8 @@ var balanceLShapes = ({
     );
     if (newPath.length === 4) {
       const [p0, p1, p2, p3] = newPath;
-      let p1New, p2New;
+      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;
@@ -2828,7 +2731,8 @@ var balanceLShapes = ({
       if (!isValidZShape) {
         continue;
       }
-      let p2New, p3New;
+      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) {
@@ -2851,198 +2755,610 @@ var balanceLShapes = ({
         i = 0;
       }
     }
-    const finalSimplifiedPath = simplifyPath(newPath);
-    return {
-      ...trace,
-      tracePath: finalSimplifiedPath
-    };
-  });
-  if (changesMade) {
-    return newTraces;
-  } else {
-    return null;
+    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];
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
+var SingleOverlapSolver = class extends BaseSolver {
+  queuedCandidatePaths;
+  solvedTracePath = null;
+  initialTrace;
+  problem;
+  obstacles;
+  label;
+  constructor(solverInput) {
+    super();
+    this.initialTrace = solverInput.trace;
+    this.problem = solverInput.problem;
+    this.label = solverInput.label;
+    const candidates = generateRerouteCandidates({
+      ...solverInput
+    });
+    const getPathLength = (pts) => {
+      let len = 0;
+      for (let i = 0; i < pts.length - 1; i++) {
+        const dx = pts[i + 1].x - pts[i].x;
+        const dy = pts[i + 1].y - pts[i].y;
+        len += Math.sqrt(dx * dx + dy * dy);
+      }
+      return len;
+    };
+    this.queuedCandidatePaths = candidates.sort(
+      (a, b) => getPathLength(a) - getPathLength(b)
+    );
+    this.obstacles = getObstacleRects(this.problem);
+  }
+  _step() {
+    if (this.queuedCandidatePaths.length === 0) {
+      this.failed = true;
+      return;
+    }
+    const nextCandidatePath = this.queuedCandidatePaths.shift();
+    const simplifiedPath = simplifyPath(nextCandidatePath);
+    if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
+      this.solvedTracePath = simplifiedPath;
+      this.solved = true;
+    }
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.problem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1
+    });
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.rects) graphics.rects = [];
+    graphics.lines.push({
+      points: this.initialTrace.tracePath,
+      strokeColor: "red",
+      strokeDash: "4 4"
+    });
+    graphics.rects.push({
+      center: this.label.center,
+      width: this.label.width,
+      height: this.label.height,
+      fill: "rgba(255, 0, 0, 0.2)"
+    });
+    if (this.queuedCandidatePaths.length > 0) {
+      graphics.lines.push({
+        points: this.queuedCandidatePaths[0],
+        strokeColor: "orange"
+      });
+    }
+    if (this.solvedTracePath) {
+      graphics.lines.push({
+        points: this.solvedTracePath,
+        strokeColor: "green"
+      });
+    }
+    return graphics;
   }
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts
-var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
-  problem;
-  traces;
-  netTempLabelPlacements;
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts
+var OverlapAvoidanceStepSolver = class extends BaseSolver {
+  inputProblem;
   netLabelPlacements;
-  updatedTraces;
   mergedLabelNetIdMap;
-  detourCountByLabel;
+  allTraces;
+  modifiedTraces = [];
+  detourCountByLabel = {};
   PADDING_BUFFER = 0.1;
+  activeSubSolver = null;
+  overlapQueue = [];
+  recentlyFailed = /* @__PURE__ */ new Set();
   constructor(solverInput) {
     super();
-    this.problem = solverInput.inputProblem;
-    this.traces = solverInput.traces;
-    this.updatedTraces = [...solverInput.traces];
-    this.mergedLabelNetIdMap = {};
-    this.detourCountByLabel = {};
-    const originalLabels = solverInput.netLabelPlacements;
-    this.netLabelPlacements = originalLabels;
-    if (!originalLabels || originalLabels.length === 0) {
-      this.netTempLabelPlacements = [];
-      return;
-    }
-    const labelGroups = {};
-    for (const p of originalLabels) {
-      if (p.pinIds.length === 0) continue;
-      const chipId = p.pinIds[0].split(".")[0];
-      if (!chipId) continue;
-      const key = `${chipId}-${p.orientation}`;
-      if (!(key in labelGroups)) {
-        labelGroups[key] = [];
-      }
-      labelGroups[key].push(p);
-    }
-    const finalPlacements = [];
-    for (const [key, group] of Object.entries(labelGroups)) {
-      if (group.length <= 1) {
-        finalPlacements.push(...group);
-        continue;
-      }
-      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-      for (const p of group) {
-        const bounds = getRectBounds(p.center, p.width, p.height);
-        minX = Math.min(minX, bounds.minX);
-        minY = Math.min(minY, bounds.minY);
-        maxX = Math.max(maxX, bounds.maxX);
-        maxY = Math.max(maxY, bounds.maxY);
-      }
-      const newWidth = maxX - minX;
-      const newHeight = maxY - minY;
-      const template = group[0];
-      const syntheticId = `merged-group-${key}`;
-      const originalNetIds = new Set(group.map((p) => p.globalConnNetId));
-      this.mergedLabelNetIdMap[syntheticId] = originalNetIds;
-      finalPlacements.push({
-        ...template,
-        globalConnNetId: syntheticId,
-        width: newWidth,
-        height: newHeight,
-        center: { x: minX + newWidth / 2, y: minY + newHeight / 2 },
-        pinIds: [...new Set(group.flatMap((p) => p.pinIds))],
-        mspConnectionPairIds: [
-          ...new Set(group.flatMap((p) => p.mspConnectionPairIds))
-        ]
-      });
-    }
-    this.netTempLabelPlacements = finalPlacements;
+    this.inputProblem = solverInput.inputProblem;
+    this.netLabelPlacements = solverInput.netLabelPlacements;
+    this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap;
+    this.allTraces = [...solverInput.traces];
   }
   _step() {
-    if (!this.traces || this.traces.length === 0 || !this.netTempLabelPlacements || this.netTempLabelPlacements.length === 0) {
-      this.solved = true;
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath;
+        if (solvedPath) {
+          const traceIndex = this.allTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver.initialTrace.mspPairId
+          );
+          if (traceIndex !== -1) {
+            this.allTraces[traceIndex].tracePath = solvedPath;
+            this.modifiedTraces.push(this.allTraces[traceIndex]);
+          }
+        }
+        this.activeSubSolver = null;
+        this.recentlyFailed.clear();
+      } else if (this.activeSubSolver.failed) {
+        const overlapId = `${this.activeSubSolver.initialTrace.mspPairId}-${this.activeSubSolver.label.globalConnNetId}`;
+        this.recentlyFailed.add(overlapId);
+        this.activeSubSolver = null;
+      }
       return;
     }
-    this.detourCountByLabel = {};
     const overlaps = detectTraceLabelOverlap(
-      this.traces,
-      this.netTempLabelPlacements
-    );
-    if (overlaps.length === 0) {
-      this.solved = true;
-      return;
-    }
-    const unfriendlyOverlaps = overlaps.filter((o) => {
+      this.allTraces,
+      this.netLabelPlacements
+    ).filter((o) => {
       const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId];
       if (originalNetIds) {
         return !originalNetIds.has(o.trace.globalConnNetId);
       }
       return o.trace.globalConnNetId !== o.label.globalConnNetId;
     });
-    if (unfriendlyOverlaps.length === 0) {
+    if (overlaps.length === 0) {
       this.solved = true;
       return;
     }
-    const updatedTracesMap = {};
-    for (const trace of this.traces) {
-      updatedTracesMap[trace.mspPairId] = trace;
+    const nonFailedOverlaps = overlaps.filter((o) => {
+      const overlapId = `${o.trace.mspPairId}-${o.label.globalConnNetId}`;
+      return !this.recentlyFailed.has(overlapId);
+    });
+    if (nonFailedOverlaps.length === 0) {
+      this.solved = true;
+      return;
     }
-    const processedTraceIds = /* @__PURE__ */ new Set();
-    for (const overlap of unfriendlyOverlaps) {
-      if (processedTraceIds.has(overlap.trace.mspPairId)) {
-        continue;
-      }
-      const currentTraceState = updatedTracesMap[overlap.trace.mspPairId];
-      const labelId = overlap.label.globalConnNetId;
-      const detourCount = this.detourCountByLabel[labelId] || 0;
-      const newTrace = rerouteCollidingTrace({
-        trace: currentTraceState,
-        label: overlap.label,
-        problem: this.problem,
-        paddingBuffer: this.PADDING_BUFFER,
-        detourCount
-      });
-      if (newTrace.tracePath !== currentTraceState.tracePath) {
+    this.overlapQueue = nonFailedOverlaps;
+    const nextOverlap = this.overlapQueue.shift();
+    if (nextOverlap) {
+      const traceToFix = this.allTraces.find(
+        (t) => t.mspPairId === nextOverlap.trace.mspPairId
+      );
+      if (traceToFix) {
+        const labelId = nextOverlap.label.globalConnNetId;
+        const detourCount = this.detourCountByLabel[labelId] || 0;
         this.detourCountByLabel[labelId] = detourCount + 1;
+        this.activeSubSolver = new SingleOverlapSolver({
+          trace: traceToFix,
+          label: nextOverlap.label,
+          problem: this.inputProblem,
+          paddingBuffer: this.PADDING_BUFFER,
+          detourCount
+        });
       }
-      updatedTracesMap[currentTraceState.mspPairId] = newTrace;
-      processedTraceIds.add(currentTraceState.mspPairId);
-    }
-    this.updatedTraces = Object.values(updatedTracesMap);
-    const minimizedTraces = minimizeTurnsWithFilteredLabels({
-      traces: this.updatedTraces,
-      problem: this.problem,
-      allLabelPlacements: this.netTempLabelPlacements,
-      // Use temp labels which include merged ones
-      mergedLabelNetIdMap: this.mergedLabelNetIdMap,
-      paddingBuffer: this.PADDING_BUFFER
-    });
-    if (minimizedTraces) {
-      this.updatedTraces = minimizedTraces;
     }
-    const balancedTraces = balanceLShapes({
-      traces: this.updatedTraces,
-      problem: this.problem,
-      allLabelPlacements: this.netLabelPlacements
-    });
-    if (balancedTraces) {
-      this.updatedTraces = balancedTraces;
+  }
+  getOutput() {
+    return {
+      allTraces: this.allTraces,
+      modifiedTraces: this.modifiedTraces
+    };
+  }
+  visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
     }
-    const finalLabelPlacementSolver = new NetLabelPlacementSolver({
-      inputProblem: this.problem,
-      inputTraceMap: Object.fromEntries(
-        this.updatedTraces.map((trace) => [trace.mspPairId, trace])
-      )
-    });
-    finalLabelPlacementSolver.solve();
-    if (!finalLabelPlacementSolver.failed) {
-      this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements;
+    const graphics = visualizeInputProblem(this.inputProblem);
+    if (!graphics.lines) graphics.lines = [];
+    for (const trace of this.allTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts
+var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  // sub-solver instances
+  labelMergingSolver;
+  overlapAvoidanceSolver;
+  traceCleanupSolver;
+  pipelineStepIndex = 0;
+  constructor(solverInput) {
+    super();
+    this.inputProblem = solverInput.inputProblem;
+    this.traces = solverInput.traces;
+    this.netLabelPlacements = solverInput.netLabelPlacements;
+  }
+  _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        this.activeSubSolver = null;
+        this.pipelineStepIndex++;
+      } else if (this.activeSubSolver.failed) {
+        this.failed = true;
+        this.activeSubSolver = null;
+      }
+      return;
+    }
+    switch (this.pipelineStepIndex) {
+      case 0:
+        this.labelMergingSolver = new MergedNetLabelObstacleSolver({
+          netLabelPlacements: this.netLabelPlacements,
+          inputProblem: this.inputProblem,
+          traces: this.traces
+        });
+        this.activeSubSolver = this.labelMergingSolver;
+        break;
+      case 1:
+        this.overlapAvoidanceSolver = new OverlapAvoidanceStepSolver({
+          inputProblem: this.inputProblem,
+          traces: this.traces,
+          netLabelPlacements: this.labelMergingSolver.getOutput().netLabelPlacements,
+          mergedLabelNetIdMap: this.labelMergingSolver.getOutput().mergedLabelNetIdMap
+        });
+        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;
     }
-    this.solved = true;
   }
   getOutput() {
     return {
-      traces: this.updatedTraces,
-      netLabelPlacements: this.netLabelPlacements
+      traces: this.traceCleanupSolver?.getOutput().traces ?? this.traces,
+      netLabelPlacements: this.labelMergingSolver?.getOutput().netLabelPlacements ?? this.netLabelPlacements
     };
   }
   visualize() {
-    const graphics = visualizeInputProblem(this.problem);
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
+    const graphics = visualizeInputProblem(this.inputProblem);
     if (!graphics.lines) graphics.lines = [];
-    if (!graphics.circles) graphics.circles = [];
-    if (!graphics.texts) graphics.texts = [];
     if (!graphics.rects) graphics.rects = [];
-    for (const trace of this.updatedTraces) {
+    const output = this.getOutput();
+    for (const trace of output.traces) {
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "purple"
       });
     }
-    for (const p of this.netLabelPlacements) {
+    for (const label of output.netLabelPlacements) {
+      const color = getColorFromString(label.globalConnNetId, 0.3);
       graphics.rects.push({
-        center: p.center,
-        width: p.width,
-        height: p.height,
-        fill: getColorFromString(p.globalConnNetId, 0.35)
-      });
-      graphics.points.push({
-        x: p.anchorPoint.x,
-        y: p.anchorPoint.y,
-        color: getColorFromString(p.globalConnNetId, 0.9)
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: color,
+        stroke: color.replace("0.3", "1"),
+        label: label.globalConnNetId
       });
     }
     return graphics;
@@ -3100,22 +3416,208 @@ var expandChipsToFitPins = (problem) => {
   }
 };
 
+// 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.subSolver) {
+      return this.subSolver.visualize();
+    }
+    const graphics = visualizeInputProblem(this.inputProblem);
+    for (const trace of this.solvedLongDistanceTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    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/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
     solverName,
     solverClass,
     getConstructorParams,
-    onSolved: opts.onSolved
+    onSolved: opts.onSolved,
+    shouldSkip: opts.shouldSkip
   };
 }
 var SchematicTracePipelineSolver = class extends BaseSolver {
   mspConnectionPairSolver;
   // guidelinesSolver?: GuidelinesSolver
   schematicTraceLinesSolver;
+  longDistancePairSolver;
   traceOverlapShiftSolver;
   netLabelPlacementSolver;
+  labelMergingSolver;
   traceLabelOverlapAvoidanceSolver;
+  traceCleanupSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -3155,6 +3657,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           // guidelines: this.guidelinesSolver!.guidelines,
           chipMap: this.mspConnectionPairSolver.chipMap
         }
+      ]
+    ),
+    definePipelineStep(
+      "longDistancePairSolver",
+      LongDistancePairSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          primaryMspConnectionPairs: instance.mspConnectionPairSolver.mspConnectionPairs,
+          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths
+        }
       ],
       {
         onSolved: (schematicTraceLinesSolver) => {
@@ -3167,7 +3680,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       () => [
         {
           inputProblem: this.inputProblem,
-          inputTracePaths: this.schematicTraceLinesSolver.solvedTracePaths,
+          inputTracePaths: this.longDistancePairSolver?.getOutput().allTracesMerged,
           globalConnMap: this.mspConnectionPairSolver.globalConnMap
         }
       ],
@@ -3183,10 +3696,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: this.inputProblem,
           inputTraceMap: this.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-            this.schematicTraceLinesSolver.solvedTracePaths.map((p) => [
-              p.mspPairId,
-              p
-            ])
+            this.longDistancePairSolver.getOutput().allTracesMerged.map(
+              (p) => [p.mspPairId, p]
+            )
           )
         }
       ],
@@ -3200,10 +3712,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       TraceLabelOverlapAvoidanceSolver,
       (instance) => {
         const traceMap = instance.traceOverlapShiftSolver?.correctedTraceMap ?? Object.fromEntries(
-          instance.schematicTraceLinesSolver.solvedTracePaths.map((p) => [
-            p.mspPairId,
-            p
-          ])
+          instance.longDistancePairSolver.getOutput().allTracesMerged.map((p) => [p.mspPairId, p])
         );
         const traces = Object.values(traceMap);
         const netLabelPlacements = instance.netLabelPlacementSolver.netLabelPlacements;
@@ -3214,14 +3723,21 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
             netLabelPlacements
           }
         ];
-      },
-      {
-        onSolved: (instance) => {
-          if (instance.traceLabelOverlapAvoidanceSolver && instance.netLabelPlacementSolver) {
-            const { netLabelPlacements } = instance.traceLabelOverlapAvoidanceSolver.getOutput();
-            instance.netLabelPlacementSolver.netLabelPlacements = netLabelPlacements;
+      }
+    ),
+    definePipelineStep(
+      "netLabelPlacementSolver",
+      NetLabelPlacementSolver,
+      (instance) => {
+        const traces = instance.traceCleanupSolver?.getOutput().traces ?? instance.traceLabelOverlapAvoidanceSolver.getOutput().traces;
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            inputTraceMap: Object.fromEntries(
+              traces.map((trace) => [trace.mspPairId, trace])
+            )
           }
-        }
+        ];
       }
     )
   ];
@@ -3307,14 +3823,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         return viz;
       })
     ];
-    if (visualizations.length === 1) return visualizations[0];
-    return {
+    if (visualizations.length === 1) {
+      return visualizations[0];
+    }
+    const finalGraphics = {
       points: visualizations.flatMap((v) => v.points || []),
       rects: visualizations.flatMap((v) => v.rects || []),
       lines: visualizations.flatMap((v) => v.lines || []),
       circles: visualizations.flatMap((v) => v.circles || []),
       texts: visualizations.flatMap((v) => v.texts || [])
     };
+    return finalGraphics;
   }
   /**
    * A lightweight version of the visualize method that can be used to stream