@tscircuit/schematic-trace-solver 0.0.41 → 0.0.43

package/dist/index.js

@@ -2196,8 +2196,161 @@ var NetLabelPlacementSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/GuidelinesSolver/GuidelinesSolver.ts
-import { getBounds as getBounds3 } from "graphics-debug";
+// 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"
+              });
+            }
+          }
+        }
+      } else {
+        graphics.rects.push({
+          center: finalLabel.center,
+          width: finalLabel.width,
+          height: finalLabel.height,
+          stroke: color,
+          label: finalLabel.globalConnNetId
+        });
+      }
+    }
+    return graphics;
+  }
+};
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap.ts
 var detectTraceLabelOverlap = (traces, netLabels) => {
@@ -2237,114 +2390,70 @@ var findTraceViolationZone = (path, labelBounds) => {
   return { firstInsideIndex, lastInsideIndex };
 };
 
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/simplifyPath.ts
-var simplifyPath = (path) => {
-  if (path.length < 3) return path;
-  const newPath = [path[0]];
-  for (let i = 1; i < path.length - 1; i++) {
-    const p1 = newPath[newPath.length - 1];
-    const p2 = path[i];
-    const p3 = path[i + 1];
-    if (isVertical(p1, p2) && isVertical(p2, p3) || isHorizontal(p1, p2) && isHorizontal(p2, p3)) {
-      continue;
-    }
-    newPath.push(p2);
-  }
-  newPath.push(path[path.length - 1]);
-  if (newPath.length < 3) return newPath;
-  const finalPath = [newPath[0]];
-  for (let i = 1; i < newPath.length - 1; i++) {
-    const p1 = finalPath[finalPath.length - 1];
-    const p2 = newPath[i];
-    const p3 = newPath[i + 1];
-    if (isVertical(p1, p2) && isVertical(p2, p3) || isHorizontal(p1, p2) && isHorizontal(p2, p3)) {
-      continue;
-    }
-    finalPath.push(p2);
-  }
-  finalPath.push(newPath[newPath.length - 1]);
-  return finalPath;
-};
-
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/trySnipAndReconnect.ts
-var trySnipAndReconnect = ({
+var generateSnipAndReconnectCandidates = ({
   initialTrace,
   firstInsideIndex,
   lastInsideIndex,
   labelBounds,
-  obstacles
+  paddingBuffer,
+  detourCount
 }) => {
   if (firstInsideIndex <= 0 || lastInsideIndex >= initialTrace.tracePath.length - 1) {
-    return null;
+    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 candidateDetours = [];
+  const allCandidateDetours = [];
   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 }]);
+    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) {
-    const newPath = [...pathToEntry, ...pathFromExit];
-    const simplified = simplifyPath(newPath);
-    if (!isPathCollidingWithObstacles(simplified, obstacles)) {
-      return { ...initialTrace, tracePath: simplified };
-    }
+    allCandidateDetours.push([]);
   }
-  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 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) {
-    candidateDetours.push([
+    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) {
-    candidateDetours.push([
+    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) {
-    candidateDetours.push([
+    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) {
-    candidateDetours.push([
+    allCandidateDetours.push([
       { x: entryPoint.x, y: bottomY },
       { x: exitPoint.x, y: bottomY }
     ]);
   }
-  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 null;
+  return allCandidateDetours.map((detour) => [
+    ...pathToEntry,
+    ...detour,
+    ...pathFromExit
+  ]);
 };
-var tryFourPointDetour = ({
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/tryFourPointDetour.ts
+var generateFourPointDetourCandidates = ({
   initialTrace,
   label,
   labelBounds,
-  obstacles,
   paddingBuffer,
   detourCount
 }) => {
@@ -2359,10 +2468,10 @@ var tryFourPointDetour = ({
       break;
     }
   }
-  if (collidingSegIndex === -1) return initialTrace;
+  if (collidingSegIndex === -1) return [];
   const pA = initialTrace.tracePath[collidingSegIndex];
   const pB = initialTrace.tracePath[collidingSegIndex + 1];
-  if (!pA || !pB) return null;
+  if (!pA || !pB) return [];
   const candidateDetours = [];
   const paddedLabelBounds = getRectBounds(
     label.center,
@@ -2411,33 +2520,53 @@ var tryFourPointDetour = ({
       );
     }
   }
-  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 candidateDetours.map((detourPoints) => [
+    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+    ...detourPoints,
+    ...initialTrace.tracePath.slice(collidingSegIndex + 1)
+  ]);
+};
+
+// lib/solvers/TraceCleanupSolver/simplifyPath.ts
+var simplifyPath = (path) => {
+  if (path.length < 3) return path;
+  const newPath = [path[0]];
+  for (let i = 1; i < path.length - 1; i++) {
+    const p1 = newPath[newPath.length - 1];
+    const p2 = path[i];
+    const p3 = path[i + 1];
+    if (isVertical(p1, p2) && isVertical(p2, p3) || isHorizontal(p1, p2) && isHorizontal(p2, p3)) {
+      continue;
     }
+    newPath.push(p2);
   }
-  return null;
+  newPath.push(path[path.length - 1]);
+  if (newPath.length < 3) return newPath;
+  const finalPath = [newPath[0]];
+  for (let i = 1; i < newPath.length - 1; i++) {
+    const p1 = finalPath[finalPath.length - 1];
+    const p2 = newPath[i];
+    const p3 = newPath[i + 1];
+    if (isVertical(p1, p2) && isVertical(p2, p3) || isHorizontal(p1, p2) && isHorizontal(p2, p3)) {
+      continue;
+    }
+    finalPath.push(p2);
+  }
+  finalPath.push(newPath[newPath.length - 1]);
+  return finalPath;
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace.ts
-var rerouteCollidingTrace = ({
+var generateRerouteCandidates = ({
   trace,
   label,
-  problem,
   paddingBuffer,
   detourCount
 }) => {
   const initialTrace = { ...trace, tracePath: simplifyPath(trace.tracePath) };
   if (trace.globalConnNetId === label.globalConnNetId) {
-    return initialTrace;
+    return [initialTrace.tracePath];
   }
-  const obstacles = getObstacleRects(problem);
   const labelPadding = paddingBuffer;
   const labelBoundsRaw = getRectBounds(label.center, label.width, label.height);
   const labelBounds = {
@@ -2447,98 +2576,589 @@ var rerouteCollidingTrace = ({
     maxY: labelBoundsRaw.maxY + labelPadding,
     chipId: `netlabel-${label.netId}`
   };
-  const fourPointResult = tryFourPointDetour({
+  const fourPointCandidates = generateFourPointDetourCandidates({
     initialTrace,
     label,
     labelBounds,
-    obstacles,
     paddingBuffer,
     detourCount
   });
-  if (fourPointResult) {
-    initialTrace.tracePath = fourPointResult.tracePath;
-  }
   const { firstInsideIndex, lastInsideIndex } = findTraceViolationZone(
     initialTrace.tracePath,
     labelBounds
   );
-  const snipReconnectResult = trySnipAndReconnect({
+  const snipReconnectCandidates = generateSnipAndReconnectCandidates({
     initialTrace,
     firstInsideIndex,
     lastInsideIndex,
     labelBounds,
-    obstacles
+    paddingBuffer,
+    detourCount
   });
-  if (snipReconnectResult) {
-    return snipReconnectResult;
-  }
-  if (fourPointResult) {
-    return fourPointResult;
-  }
-  return initialTrace;
+  return [...fourPointCandidates, ...snipReconnectCandidates];
 };
 
-// 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;
-      }
+// 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;
     }
   }
-  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++;
+  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;
   }
-  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]);
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts
+var OverlapAvoidanceStepSolver = class extends BaseSolver {
+  inputProblem;
+  netLabelPlacements;
+  mergedLabelNetIdMap;
+  allTraces;
+  modifiedTraces = [];
+  detourCountByLabel = {};
+  PADDING_BUFFER = 0.1;
+  activeSubSolver = null;
+  overlapQueue = [];
+  recentlyFailed = /* @__PURE__ */ new Set();
+  constructor(solverInput) {
+    super();
+    this.inputProblem = solverInput.inputProblem;
+    this.netLabelPlacements = solverInput.netLabelPlacements;
+    this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap;
+    this.allTraces = [...solverInput.traces];
   }
-  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;
+  _step() {
+    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;
     }
-  }
-  return false;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts
-var minimizeTurns = ({
-  path,
-  obstacles,
-  labelBounds
+    const overlaps = detectTraceLabelOverlap(
+      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 (overlaps.length === 0) {
+      this.solved = true;
+      return;
+    }
+    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;
+    }
+    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
+        });
+      }
+    }
+  }
+  getOutput() {
+    return {
+      allTraces: this.allTraces,
+      modifiedTraces: this.modifiedTraces
+    };
+  }
+  visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
+    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;
+  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;
+      default:
+        this.solved = true;
+        break;
+    }
+  }
+  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.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/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;
+      }
+    }
+  }
+  return false;
+};
+
+// 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++;
+    }
+  }
+  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;
@@ -2595,7 +3215,6 @@ var minimizeTurns = ({
           );
           if (!collidesWithObstacles && !collidesWithLabels) {
             const newTurns = countTurns(testPath);
-            const turnsRemoved = stairEndIdx - startIdx - 1;
             optimizedPath = testPath;
             currentTurns = newTurns;
             improved = true;
@@ -2665,621 +3284,294 @@ var minimizeTurns = ({
             labelBounds
           );
           if (!collidesWithObstacles && !collidesWithLabels) {
-            optimizedPath = testPath;
-            improved = true;
-            break;
-          }
-        }
-      }
-    }
-  }
-  const finalSimplifiedPath = simplifyPath(optimizedPath);
-  return finalSimplifiedPath;
-};
-
-// lib/solvers/TraceLabelOverlapAvoidanceSolver/minimizeTurnsWithFilteredLabels.ts
-var minimizeTurnsWithFilteredLabels = ({
-  traces,
-  problem,
-  allLabelPlacements,
-  mergedLabelNetIdMap,
-  paddingBuffer
-}) => {
-  let changesMade = false;
-  const obstacles = getObstacleRects(problem);
-  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/balanceLShapes.ts
-var balanceLShapes = ({
-  traces,
-  problem,
-  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(problem).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) => {
-    let 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, 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, 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/TraceLabelOverlapAvoidanceSolver.ts
-var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
-  problem;
-  traces;
-  netTempLabelPlacements;
-  netLabelPlacements;
-  updatedTraces;
-  mergedLabelNetIdMap;
-  detourCountByLabel;
-  PADDING_BUFFER = 0.1;
-  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;
-  }
-  _step() {
-    if (!this.traces || this.traces.length === 0 || !this.netTempLabelPlacements || this.netTempLabelPlacements.length === 0) {
-      this.solved = true;
-      return;
-    }
-    this.detourCountByLabel = {};
-    const overlaps = detectTraceLabelOverlap(
-      this.traces,
-      this.netTempLabelPlacements
-    );
-    if (overlaps.length === 0) {
-      this.solved = true;
-      return;
-    }
-    const unfriendlyOverlaps = overlaps.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) {
-      this.solved = true;
-      return;
-    }
-    const updatedTracesMap = {};
-    for (const trace of this.traces) {
-      updatedTracesMap[trace.mspPairId] = trace;
-    }
-    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.detourCountByLabel[labelId] = detourCount + 1;
-      }
-      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;
-    }
-    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;
-    }
-    this.solved = true;
-  }
-  getOutput() {
-    return {
-      traces: this.updatedTraces,
-      netLabelPlacements: this.netLabelPlacements
-    };
-  }
-  visualize() {
-    const graphics = visualizeInputProblem(this.problem);
-    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) {
-      graphics.lines.push({
-        points: trace.tracePath,
-        strokeColor: "purple"
-      });
-    }
-    for (const p of this.netLabelPlacements) {
-      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)
-      });
-    }
-    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;
+            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
@@ -3299,7 +3591,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   longDistancePairSolver;
   traceOverlapShiftSolver;
   netLabelPlacementSolver;
+  labelMergingSolver;
   traceLabelOverlapAvoidanceSolver;
+  traceCleanupSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -3405,14 +3699,36 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
             netLabelPlacements
           }
         ];
-      },
-      {
-        onSolved: (instance) => {
-          if (instance.traceLabelOverlapAvoidanceSolver && instance.netLabelPlacementSolver) {
-            const { netLabelPlacements } = instance.traceLabelOverlapAvoidanceSolver.getOutput();
-            instance.netLabelPlacementSolver.netLabelPlacements = netLabelPlacements;
-          }
+      }
+    ),
+    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,
+      (instance) => {
+        const traces = instance.traceCleanupSolver?.getOutput().traces ?? instance.traceLabelOverlapAvoidanceSolver.getOutput().traces;
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            inputTraceMap: Object.fromEntries(
+              traces.map((trace) => [trace.mspPairId, trace])
+            )
+          }
+        ];
       }
     )
   ];
@@ -3498,14 +3814,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