@tscircuit/schematic-trace-solver 0.0.44 → 0.0.46

package/dist/index.js

@@ -271,19 +271,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS4 = 1e-9;
+  const EPS5 = 1e-9;
   const crossesSegment = (a, b) => {
     for (const [, rcl] of restrictedCenterLines) {
       if (rcl.axes.has("x") && typeof rcl.x === "number") {
-        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS4) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS5) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS4) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS5) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS4 || Math.abs(p1.y - p2.y) < EPS4) {
+  if (Math.abs(p1.x - p2.x) < EPS5 || Math.abs(p1.y - p2.y) < EPS5) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -810,8 +810,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS4 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS4 && Math.abs(p.y - q.y) < EPS4;
+      const EPS5 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS5 && Math.abs(p.y - q.y) < EPS5;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1010,17 +1010,17 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS4 = 1e-6
+  EPS: EPS5 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical2 = Math.abs(start.x - end.x) < EPS4;
-  const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
-  if (!isVertical2 && !isHorizontal2) return;
-  const segDir = isVertical2 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  const isVertical3 = Math.abs(start.x - end.x) < EPS5;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS5;
+  if (!isVertical3 && !isHorizontal2) return;
+  const segDir = isVertical3 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
-    if (isVertical2) {
+    if (isVertical3) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1040,7 +1040,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical2) {
+    if (isVertical3) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1083,13 +1083,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS4 = 1e-6;
+    const EPS5 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS4;
+    const eq = (a, b) => Math.abs(a - b) < EPS5;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -1115,15 +1115,15 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS4
+              EPS: EPS5
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical2 = Math.abs(start.x - end.x) < EPS4;
-            const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
-            if (!isVertical2 && !isHorizontal2) continue;
-            if (isVertical2) {
+            const isVertical3 = Math.abs(start.x - end.x) < EPS5;
+            const isHorizontal2 = Math.abs(start.y - end.y) < EPS5;
+            if (!isVertical3 && !isHorizontal2) continue;
+            if (isVertical3) {
               start.x += offset;
               end.x += offset;
             } else {
@@ -1218,7 +1218,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS4 = 2e-3;
+    const EPS5 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -1236,7 +1236,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS4;
+          return overlap > EPS5;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1244,8 +1244,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS4;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS4;
+            const aVert = Math.abs(a1.x - a2.x) < EPS5;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS5;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -1253,11 +1253,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS4;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS4;
+                const bVert = Math.abs(b1.x - b2.x) < EPS5;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS5;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS4) {
+                  if (Math.abs(a1.x - b1.x) < EPS5) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1278,7 +1278,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS4) {
+                  if (Math.abs(a1.y - b1.y) < EPS5) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1316,15 +1316,15 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS4 = 2e-3;
+    const EPS5 = 2e-3;
     for (const mspPairId in this.correctedTraceMap) {
       const tracePath = this.correctedTraceMap[mspPairId].tracePath;
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal2 = Math.abs(p1.y - p2.y) < EPS4;
-        const isVertical2 = Math.abs(p1.x - p2.x) < EPS4;
-        if (!isHorizontal2 && !isVertical2) {
+        const isHorizontal2 = Math.abs(p1.y - p2.y) < EPS5;
+        const isVertical3 = Math.abs(p1.x - p2.x) < EPS5;
+        if (!isHorizontal2 && !isVertical3) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
       }
@@ -1337,13 +1337,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS4 = 2e-3;
+    const EPS5 = 2e-3;
     const p0 = i > 0 ? tracePath[i - 1] : null;
     const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null;
-    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS4 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS4 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS4 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS4 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS5 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS5 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS5 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS5 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -1507,24 +1507,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS4 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS4;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS4;
+function segmentIntersectsRect2(p1, p2, rect, EPS5 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS5;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS5;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS4 || x > rect.maxX + EPS4) return false;
+    if (x < rect.minX - EPS5 || x > rect.maxX + EPS5) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS4;
+    return overlap > EPS5;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS4 || y > rect.maxY + EPS4) return false;
+    if (y < rect.minY - EPS5 || y > rect.maxY + EPS5) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS4;
+    return overlap > EPS5;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1893,14 +1893,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS4 = 1e-6;
+    const EPS5 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS4;
-        const isV = Math.abs(a.x - b.x) < EPS4;
+        const isH = Math.abs(a.y - b.y) < EPS5;
+        const isV = Math.abs(a.x - b.x) < EPS5;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -2260,12 +2260,134 @@ var NetLabelPlacementSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/groupLabelsByChipAndOrientation.ts
+var groupLabelsByChipAndOrientation = ({
+  labels,
+  chips
+}) => {
+  const groupedLabels = {};
+  for (const label of labels) {
+    if (label.pinIds.length === 0) {
+      continue;
+    }
+    const chipId = label.pinIds[0].split(".")[0];
+    if (!chipId) {
+      continue;
+    }
+    const key = `${chipId}-${label.orientation}`;
+    if (!groupedLabels[key]) {
+      groupedLabels[key] = [];
+    }
+    groupedLabels[key].push(label);
+  }
+  return groupedLabels;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/mergeLabelGroup.ts
+var mergeLabelGroup = (group, groupKey) => {
+  if (group.length === 0) {
+    throw new Error("Cannot merge an empty group of labels.");
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const allPinIds = /* @__PURE__ */ new Set();
+  const allMspConnectionPairIds = /* @__PURE__ */ new Set();
+  const originalNetIds = /* @__PURE__ */ new Set();
+  for (const label of group) {
+    const bounds = getRectBounds(label.center, label.width, label.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);
+    label.pinIds.forEach((id) => allPinIds.add(id));
+    label.mspConnectionPairIds.forEach((id) => allMspConnectionPairIds.add(id));
+    originalNetIds.add(label.globalConnNetId);
+  }
+  const newWidth = maxX - minX;
+  const newHeight = maxY - minY;
+  const newCenter = { x: minX + newWidth / 2, y: minY + newHeight / 2 };
+  const template = group[0];
+  const syntheticId = `merged-group-${groupKey}`;
+  const mergedLabel = {
+    ...template,
+    // Copy common properties
+    globalConnNetId: syntheticId,
+    center: newCenter,
+    width: newWidth,
+    height: newHeight,
+    pinIds: Array.from(allPinIds),
+    mspConnectionPairIds: Array.from(allMspConnectionPairIds)
+  };
+  return {
+    mergedLabel,
+    originalNetIds
+  };
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/filterLabelsAtTraceEdges.ts
+import { distance } from "@tscircuit/math-utils";
+var filterLabelsAtTraceEdges = ({
+  labels,
+  traces,
+  distanceThreshold = 0.5
+  // Example threshold
+}) => {
+  const tracesByNetId = /* @__PURE__ */ new Map();
+  if (!traces) {
+    throw new Error("No traces provided to filterLabelsAtTraceEdges");
+  }
+  for (const trace of traces) {
+    if (!trace.globalConnNetId) continue;
+    if (!tracesByNetId.has(trace.globalConnNetId)) {
+      tracesByNetId.set(trace.globalConnNetId, []);
+    }
+    tracesByNetId.get(trace.globalConnNetId).push(trace);
+  }
+  const filteredLabels = [];
+  for (const label of labels) {
+    if (label.mspConnectionPairIds.length === 0) {
+      filteredLabels.push(label);
+      continue;
+    }
+    const relevantTraces = tracesByNetId.get(label.globalConnNetId);
+    let isNearTraceEdge = false;
+    if (!relevantTraces || relevantTraces.length === 0) {
+      continue;
+    }
+    for (const trace of relevantTraces) {
+      if (trace.tracePath.length === 0) continue;
+      const startPoint = trace.tracePath[0];
+      const endPoint = trace.tracePath[trace.tracePath.length - 1];
+      const startDist = distance(label.center, startPoint);
+      const endDist = distance(label.center, endPoint);
+      if (startDist <= distanceThreshold || endDist <= distanceThreshold) {
+        isNearTraceEdge = true;
+        break;
+      }
+    }
+    if (isNearTraceEdge) {
+      filteredLabels.push(label);
+    }
+  }
+  return filteredLabels;
+};
+
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/LabelMergingSolver.ts
 var MergedNetLabelObstacleSolver = class extends BaseSolver {
   input;
   output;
   inputProblem;
   traces;
+  // State for the new pipeline
+  pipelineStep = "filtering_labels";
+  filteredLabels = [];
+  labelGroups = {};
+  groupKeysToProcess = [];
+  finalPlacements = [];
+  mergedLabelNetIdMap = {};
+  activeMergingGroupKey = null;
   constructor(solverInput) {
     super();
     this.input = solverInput;
@@ -2277,67 +2399,58 @@ var MergedNetLabelObstacleSolver = class extends BaseSolver {
     };
   }
   _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))
-        ]
-      });
+    switch (this.pipelineStep) {
+      case "filtering_labels":
+        this.filteredLabels = filterLabelsAtTraceEdges({
+          labels: this.input.netLabelPlacements,
+          traces: this.traces
+        });
+        this.pipelineStep = "grouping_labels";
+        break;
+      case "grouping_labels":
+        this.labelGroups = groupLabelsByChipAndOrientation({
+          labels: this.filteredLabels,
+          chips: this.inputProblem.chips
+        });
+        this.groupKeysToProcess = Object.keys(this.labelGroups);
+        this.pipelineStep = "merging_groups";
+        break;
+      case "merging_groups":
+        if (this.groupKeysToProcess.length === 0) {
+          this.pipelineStep = "finalizing";
+          this.activeMergingGroupKey = null;
+          break;
+        }
+        const groupKey = this.groupKeysToProcess.pop();
+        this.activeMergingGroupKey = groupKey;
+        const group = this.labelGroups[groupKey];
+        if (group.length > 1) {
+          const { mergedLabel, originalNetIds } = mergeLabelGroup(
+            group,
+            groupKey
+          );
+          this.finalPlacements.push(mergedLabel);
+          this.mergedLabelNetIdMap[mergedLabel.globalConnNetId] = originalNetIds;
+        } else {
+          this.finalPlacements.push(...group);
+        }
+        break;
+      case "finalizing":
+        const processedOriginalIds = new Set(
+          this.finalPlacements.flatMap(
+            (p) => this.mergedLabelNetIdMap[p.globalConnNetId] ? [...this.mergedLabelNetIdMap[p.globalConnNetId]] : [p.globalConnNetId]
+          )
+        );
+        const unprocessedLabels = this.input.netLabelPlacements.filter(
+          (l) => !processedOriginalIds.has(l.globalConnNetId)
+        );
+        this.output = {
+          netLabelPlacements: [...this.finalPlacements, ...unprocessedLabels],
+          mergedLabelNetIdMap: this.mergedLabelNetIdMap
+        };
+        this.solved = true;
+        break;
     }
-    this.output = {
-      netLabelPlacements: finalPlacements,
-      mergedLabelNetIdMap
-    };
-    this.solved = true;
   }
   getOutput() {
     return this.output;
@@ -2362,6 +2475,19 @@ var MergedNetLabelObstacleSolver = class extends BaseSolver {
       };
       graphics.lines.push(line);
     }
+    if (this.activeMergingGroupKey && this.labelGroups[this.activeMergingGroupKey]) {
+      const activeGroup = this.labelGroups[this.activeMergingGroupKey];
+      for (const label of activeGroup) {
+        graphics.rects.push({
+          center: label.center,
+          width: label.width,
+          height: label.height,
+          fill: "rgba(255, 165, 0, 0.5)",
+          // Orange highlight
+          stroke: "orange"
+        });
+      }
+    }
     for (const finalLabel of this.output.netLabelPlacements) {
       const isMerged = finalLabel.globalConnNetId.startsWith("merged-group-");
       const color = getColorFromString(finalLabel.globalConnNetId);
@@ -2371,7 +2497,6 @@ var MergedNetLabelObstacleSolver = class extends BaseSolver {
           width: finalLabel.width,
           height: finalLabel.height,
           fill: color.replace(/, 1\)/, ", 0.2)"),
-          // semi-transparent
           stroke: color,
           label: finalLabel.globalConnNetId
         });
@@ -2417,14 +2542,17 @@ var MergedNetLabelObstacleSolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap.ts
-var detectTraceLabelOverlap = (traces, netLabels) => {
+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];
+      for (let j = 0; j < trace.tracePath.length - 1; j++) {
+        const p1 = trace.tracePath[j];
+        const p2 = trace.tracePath[j + 1];
         if (segmentIntersectsRect2(p1, p2, labelBounds)) {
           if (trace.globalConnNetId === label.globalConnNetId) {
             break;
@@ -2738,10 +2866,45 @@ var SingleOverlapSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/isPointInsideLabel.ts
+var isPointInsideLabel = ({
+  point,
+  label
+}) => {
+  const bounds = getRectBounds(label.center, label.width, label.height);
+  return point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/visualizeDecomposition.ts
+var visualizeDecomposition = (params) => {
+  const { decomposedChildLabels, collidingTrace, mergedLabel, graphics } = params;
+  if (!graphics.rects) graphics.rects = [];
+  if (!graphics.texts) graphics.texts = [];
+  for (const childLabel of decomposedChildLabels) {
+    const isOwnLabel = childLabel.globalConnNetId === collidingTrace.globalConnNetId;
+    graphics.rects.push({
+      center: childLabel.center,
+      width: childLabel.width,
+      height: childLabel.height,
+      fill: isOwnLabel ? "green" : "red"
+      // Green for own label, red for others
+    });
+  }
+  graphics.texts.push({
+    x: mergedLabel.center.x,
+    y: mergedLabel.center.y + mergedLabel.height / 2 + 0.5,
+    text: `DECOMPOSITION: Trace ${collidingTrace.mspPairId} vs Merged Label ${mergedLabel.globalConnNetId}`,
+    fontSize: 0.3,
+    color: "blue"
+  });
+  return graphics;
+};
+
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts
 var OverlapAvoidanceStepSolver = class extends BaseSolver {
   inputProblem;
-  netLabelPlacements;
+  initialNetLabelPlacements;
+  mergedNetLabelPlacements;
   mergedLabelNetIdMap;
   allTraces;
   modifiedTraces = [];
@@ -2750,14 +2913,19 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
   activeSubSolver = null;
   overlapQueue = [];
   recentlyFailed = /* @__PURE__ */ new Set();
+  currentlyProcessingOverlap = null;
+  decomposedChildLabels = null;
   constructor(solverInput) {
     super();
     this.inputProblem = solverInput.inputProblem;
-    this.netLabelPlacements = solverInput.netLabelPlacements;
+    this.initialNetLabelPlacements = solverInput.initialNetLabelPlacements;
+    this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements;
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap;
     this.allTraces = [...solverInput.traces];
   }
   _step() {
+    this.currentlyProcessingOverlap = null;
+    this.decomposedChildLabels = null;
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
       if (this.activeSubSolver.solved) {
@@ -2777,18 +2945,13 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         const overlapId = `${this.activeSubSolver.initialTrace.mspPairId}-${this.activeSubSolver.label.globalConnNetId}`;
         this.recentlyFailed.add(overlapId);
         this.activeSubSolver = null;
+      } else {
       }
       return;
     }
-    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;
+    const overlaps = detectTraceLabelOverlap({
+      traces: this.allTraces,
+      netLabels: this.mergedNetLabelPlacements
     });
     if (overlaps.length === 0) {
       this.solved = true;
@@ -2804,22 +2967,91 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
     }
     this.overlapQueue = nonFailedOverlaps;
     const nextOverlap = this.overlapQueue.shift();
+    this.currentlyProcessingOverlap = nextOverlap ?? null;
     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
-        });
+      const labelToAvoid = nextOverlap.label;
+      const traceStartPoint = traceToFix.tracePath[0];
+      const originalNetIds = this.mergedLabelNetIdMap[labelToAvoid.globalConnNetId];
+      const isSelfOverlap = originalNetIds?.has(traceToFix.globalConnNetId);
+      if (isSelfOverlap) {
+        const childLabels = this.initialNetLabelPlacements.filter(
+          (l) => originalNetIds.has(l.globalConnNetId)
+        );
+        this.decomposedChildLabels = childLabels;
+        let actualOverlapLabel = null;
+        for (const childLabel of childLabels) {
+          const overlapsWithChild = detectTraceLabelOverlap({
+            traces: [traceToFix],
+            netLabels: [childLabel]
+          });
+          if (overlapsWithChild.length > 0) {
+            actualOverlapLabel = childLabel;
+            break;
+          }
+        }
+        if (actualOverlapLabel) {
+          const labelId2 = actualOverlapLabel.globalConnNetId;
+          const detourCount2 = this.detourCountByLabel[labelId2] || 0;
+          this.detourCountByLabel[labelId2] = detourCount2 + 1;
+          this.activeSubSolver = new SingleOverlapSolver({
+            trace: traceToFix,
+            label: actualOverlapLabel,
+            problem: this.inputProblem,
+            paddingBuffer: this.PADDING_BUFFER,
+            detourCount: detourCount2
+          });
+        } else {
+          const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
+          this.recentlyFailed.add(overlapId);
+        }
+        return;
       }
+      if (originalNetIds && isPointInsideLabel({ point: traceStartPoint, label: labelToAvoid })) {
+        const childLabels = this.initialNetLabelPlacements.filter(
+          (l) => originalNetIds.has(l.globalConnNetId)
+        );
+        this.decomposedChildLabels = childLabels;
+        let actualOverlapLabel = null;
+        for (const childLabel of childLabels) {
+          const overlapsWithChild = detectTraceLabelOverlap({
+            traces: [traceToFix],
+            netLabels: [childLabel]
+          });
+          if (overlapsWithChild.length > 0) {
+            actualOverlapLabel = childLabel;
+            break;
+          }
+        }
+        if (actualOverlapLabel) {
+          const labelId2 = actualOverlapLabel.globalConnNetId;
+          const detourCount2 = this.detourCountByLabel[labelId2] || 0;
+          this.detourCountByLabel[labelId2] = detourCount2 + 1;
+          this.activeSubSolver = new SingleOverlapSolver({
+            trace: traceToFix,
+            label: actualOverlapLabel,
+            problem: this.inputProblem,
+            paddingBuffer: this.PADDING_BUFFER,
+            detourCount: detourCount2
+          });
+        } else {
+          const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`;
+          this.recentlyFailed.add(overlapId);
+        }
+        return;
+      }
+      const labelId = labelToAvoid.globalConnNetId;
+      const detourCount = this.detourCountByLabel[labelId] || 0;
+      this.detourCountByLabel[labelId] = detourCount + 1;
+      this.activeSubSolver = new SingleOverlapSolver({
+        trace: traceToFix,
+        label: labelToAvoid,
+        problem: this.inputProblem,
+        paddingBuffer: this.PADDING_BUFFER,
+        detourCount
+      });
     }
   }
   getOutput() {
@@ -2840,6 +3072,37 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         strokeColor: "purple"
       });
     }
+    if (this.currentlyProcessingOverlap) {
+      const { trace, label } = this.currentlyProcessingOverlap;
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "red"
+      });
+      if (this.decomposedChildLabels) {
+        visualizeDecomposition({
+          decomposedChildLabels: this.decomposedChildLabels,
+          collidingTrace: trace,
+          mergedLabel: label,
+          graphics
+        });
+      } else {
+        if (!graphics.rects) graphics.rects = [];
+        graphics.rects.push({
+          center: label.center,
+          width: label.width,
+          height: label.height,
+          fill: "yellow"
+        });
+        if (!graphics.texts) graphics.texts = [];
+        graphics.texts.push({
+          x: label.center.x,
+          y: label.center.y + label.height / 2 + 0.5,
+          text: `COLLISION: Trace ${trace.mspPairId} vs Label ${label.globalConnNetId}`,
+          fontSize: 0.3,
+          color: "red"
+        });
+      }
+    }
     return graphics;
   }
 };
@@ -2884,7 +3147,9 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
         this.overlapAvoidanceSolver = new OverlapAvoidanceStepSolver({
           inputProblem: this.inputProblem,
           traces: this.traces,
-          netLabelPlacements: this.labelMergingSolver.getOutput().netLabelPlacements,
+          initialNetLabelPlacements: this.netLabelPlacements,
+          // The original, unfiltered list
+          mergedNetLabelPlacements: this.labelMergingSolver.getOutput().netLabelPlacements,
           mergedLabelNetIdMap: this.labelMergingSolver.getOutput().mergedLabelNetIdMap
         });
         this.activeSubSolver = this.overlapAvoidanceSolver;
@@ -3006,7 +3271,7 @@ function doesTraceOverlapWithExistingTraces(newTracePath, existingTraces) {
 
 // lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts
 var NEAREST_NEIGHBOR_COUNT = 3;
-var distance = (p1, p2) => {
+var distance2 = (p1, p2) => {
   return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
 };
 var LongDistancePairSolver = class extends BaseSolver {
@@ -3047,7 +3312,7 @@ var LongDistancePairSolver = class extends BaseSolver {
           return [
             {
               pin: targetPin,
-              distance: distance(sourcePin, targetPin)
+              distance: distance2(sourcePin, targetPin)
             }
           ];
         }).sort((a, b) => a.distance - b.distance).slice(0, NEAREST_NEIGHBOR_COUNT);
@@ -3163,12 +3428,21 @@ var LongDistancePairSolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceCleanupSolver/hasCollisions.ts
+import { segmentToBoxMinDistance } from "@tscircuit/math-utils";
 var hasCollisions = (pathSegments, obstacles) => {
   for (let i = 0; i < pathSegments.length - 1; i++) {
     const p1 = pathSegments[i];
     const p2 = pathSegments[i + 1];
     for (const obstacle of obstacles) {
-      if (segmentIntersectsRect(p1, p2, obstacle)) {
+      const box = {
+        center: {
+          x: obstacle.minX + (obstacle.maxX - obstacle.minX) / 2,
+          y: obstacle.minY + (obstacle.maxY - obstacle.minY) / 2
+        },
+        width: obstacle.maxX - obstacle.minX,
+        height: obstacle.maxY - obstacle.minY
+      };
+      if (segmentToBoxMinDistance(p1, p2, box) <= 0) {
         return true;
       }
     }
@@ -3218,43 +3492,60 @@ var hasCollisionsWithLabels = (pathSegments, labels) => {
   return false;
 };
 
+// lib/solvers/TraceCleanupSolver/recognizeStairStepPattern.ts
+var recognizeStairStepPattern = (pathToCheck, startIdx) => {
+  if (startIdx >= pathToCheck.length - 3) return -1;
+  let endIdx = startIdx;
+  let isStairStep = true;
+  for (let i = startIdx; i < pathToCheck.length - 2 && i < startIdx + 10; i++) {
+    if (i + 2 >= pathToCheck.length) break;
+    const p1 = pathToCheck[i];
+    const p2 = pathToCheck[i + 1];
+    const p3 = pathToCheck[i + 2];
+    const seg1Vertical = p1.x === p2.x;
+    const seg2Vertical = p2.x === p3.x;
+    if (seg1Vertical === seg2Vertical) {
+      break;
+    }
+    const seg1Direction = seg1Vertical ? Math.sign(p2.y - p1.y) : Math.sign(p2.x - p1.x);
+    if (i > startIdx) {
+      const prevP = pathToCheck[i - 1];
+      const prevSegVertical = prevP.x === p1.x;
+      const prevDirection = prevSegVertical ? Math.sign(p1.y - prevP.y) : Math.sign(p1.x - prevP.x);
+      if (seg1Vertical && prevSegVertical && seg1Direction !== prevDirection || !seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection) {
+        isStairStep = false;
+        break;
+      }
+    }
+    endIdx = i + 2;
+  }
+  return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
+};
+
+// lib/solvers/TraceCleanupSolver/isSegmentAnEndpointSegment.ts
+var isSegmentAnEndpointSegment = (p1, p2, originalPath) => {
+  if (originalPath.length < 2) return false;
+  const originalStart = originalPath[0];
+  const originalEnd = originalPath[originalPath.length - 1];
+  if (p1.x === originalStart.x && p1.y === originalStart.y && p2.x === originalPath[1].x && p2.y === originalPath[1].y) {
+    return true;
+  }
+  if (p1.x === originalPath[originalPath.length - 2].x && p1.y === originalPath[originalPath.length - 2].y && p2.x === originalEnd.x && p2.y === originalEnd.y) {
+    return true;
+  }
+  return false;
+};
+
 // lib/solvers/TraceCleanupSolver/turnMinimization.ts
 var minimizeTurns = ({
   path,
   obstacles,
-  labelBounds
+  labelBounds,
+  originalPath
 }) => {
   if (path.length <= 2) {
     return path;
   }
-  const recognizeStairStepPattern = (pathToCheck, startIdx) => {
-    if (startIdx >= pathToCheck.length - 3) return -1;
-    let endIdx = startIdx;
-    let isStairStep = true;
-    for (let i = startIdx; i < pathToCheck.length - 2 && i < startIdx + 10; i++) {
-      if (i + 2 >= pathToCheck.length) break;
-      const p1 = pathToCheck[i];
-      const p2 = pathToCheck[i + 1];
-      const p3 = pathToCheck[i + 2];
-      const seg1Vertical = p1.x === p2.x;
-      const seg2Vertical = p2.x === p3.x;
-      if (seg1Vertical === seg2Vertical) {
-        break;
-      }
-      const seg1Direction = seg1Vertical ? Math.sign(p2.y - p1.y) : Math.sign(p2.x - p1.x);
-      if (i > startIdx) {
-        const prevP = pathToCheck[i - 1];
-        const prevSegVertical = prevP.x === p1.x;
-        const prevDirection = prevSegVertical ? Math.sign(p1.y - prevP.y) : Math.sign(p1.x - prevP.x);
-        if (seg1Vertical && prevSegVertical && seg1Direction !== prevDirection || !seg1Vertical && !prevSegVertical && seg1Direction !== prevDirection) {
-          isStairStep = false;
-          break;
-        }
-      }
-      endIdx = i + 2;
-    }
-    return isStairStep && endIdx - startIdx >= 3 ? endIdx : -1;
-  };
   let optimizedPath = [...path];
   let currentTurns = countTurns(optimizedPath);
   let improved = true;
@@ -3263,6 +3554,17 @@ var minimizeTurns = ({
     for (let startIdx = 0; startIdx < optimizedPath.length - 3; startIdx++) {
       const stairEndIdx = recognizeStairStepPattern(optimizedPath, startIdx);
       if (stairEndIdx > 0) {
+        if (isSegmentAnEndpointSegment(
+          optimizedPath[startIdx],
+          optimizedPath[startIdx + 1],
+          originalPath
+        ) || isSegmentAnEndpointSegment(
+          optimizedPath[stairEndIdx - 1],
+          optimizedPath[stairEndIdx],
+          originalPath
+        )) {
+          continue;
+        }
         const startPoint = optimizedPath[startIdx];
         const endPoint = optimizedPath[stairEndIdx];
         const connectionOptions = tryConnectPoints(startPoint, endPoint);
@@ -3297,6 +3599,17 @@ var minimizeTurns = ({
         for (let removeCount = 1; removeCount <= maxRemove; removeCount++) {
           const endIdx = startIdx + removeCount + 1;
           if (endIdx >= optimizedPath.length) continue;
+          if (isSegmentAnEndpointSegment(
+            optimizedPath[startIdx],
+            optimizedPath[startIdx + 1],
+            originalPath
+          ) || isSegmentAnEndpointSegment(
+            optimizedPath[endIdx - 1],
+            optimizedPath[endIdx],
+            originalPath
+          )) {
+            continue;
+          }
           const startPoint = optimizedPath[startIdx];
           const endPoint = optimizedPath[endIdx];
           const connectionOptions = tryConnectPoints(startPoint, endPoint);
@@ -3335,6 +3648,9 @@ var minimizeTurns = ({
         const p1 = optimizedPath[i];
         const p2 = optimizedPath[i + 1];
         const p3 = optimizedPath[i + 2];
+        if (isSegmentAnEndpointSegment(p1, p2, originalPath) || isSegmentAnEndpointSegment(p2, p3, originalPath)) {
+          continue;
+        }
         const allVertical = p1.x === p2.x && p2.x === p3.x;
         const allHorizontal = p1.y === p2.y && p2.y === p3.y;
         if (allVertical || allHorizontal) {
@@ -3391,7 +3707,15 @@ var minimizeTurnsWithFilteredLabels = ({
       };
     })
   );
-  const staticObstacles = getObstacleRects(inputProblem);
+  const staticObstaclesRaw = getObstacleRects(inputProblem);
+  const PADDING = 0.01;
+  const staticObstacles = staticObstaclesRaw.map((obs) => ({
+    ...obs,
+    minX: obs.minX - PADDING,
+    minY: obs.minY - PADDING,
+    maxX: obs.maxX + PADDING,
+    maxY: obs.maxY + PADDING
+  }));
   const combinedObstacles = [...staticObstacles, ...traceObstacles];
   const originalPath = targetTrace.tracePath;
   const filteredLabels = allLabelPlacements.filter((label) => {
@@ -3410,7 +3734,8 @@ var minimizeTurnsWithFilteredLabels = ({
   const newPath = minimizeTurns({
     path: originalPath,
     obstacles: combinedObstacles,
-    labelBounds
+    labelBounds,
+    originalPath
   });
   return {
     ...targetTrace,
@@ -3554,48 +3879,645 @@ var balanceZShapes = ({
   };
 };
 
+// lib/solvers/TraceCleanupSolver/sub-solver/findAllLShapedTurns.ts
+var findAllLShapedTurns = (tracePath) => {
+  const lShapes = [];
+  if (tracePath.length < 3) {
+    return lShapes;
+  }
+  for (let i = 0; i < tracePath.length - 2; i++) {
+    const p1 = tracePath[i];
+    const p2 = tracePath[i + 1];
+    const p3 = tracePath[i + 2];
+    const dx1 = p2.x - p1.x;
+    const dy1 = p2.y - p1.y;
+    const dx2 = p3.x - p2.x;
+    const dy2 = p3.y - p2.y;
+    if ((dx1 === 0 && dy2 === 0 && dy1 !== 0 && dx2 !== 0 || // Vertical then Horizontal
+    dy1 === 0 && dx2 === 0 && dx1 !== 0 && dy2 !== 0) && // Horizontal then Vertical
+    dx1 * dx1 + dy1 * dy1 >= 0.25 && // p1-p2 arm length >= 0.5
+    dx2 * dx2 + dy2 * dy2 >= 0.25) {
+      lShapes.push({ p1, p2, p3 });
+    }
+  }
+  return lShapes;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/getTraceObstacles.ts
+var getTraceObstacles = (allTraces, excludeTraceId) => {
+  const obstacles = [];
+  for (const trace of allTraces) {
+    if (trace.mspPairId !== excludeTraceId) {
+      obstacles.push({ points: trace.tracePath });
+    }
+  }
+  return obstacles;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles.ts
+import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
+var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
+  const intersections = [];
+  for (const obstacle of obstacles) {
+    const obstaclePath = obstacle.points;
+    for (let i = 0; i < obstaclePath.length - 1; i++) {
+      const o1 = obstaclePath[i];
+      const o2 = obstaclePath[i + 1];
+      if (!o1 || !o2) {
+        continue;
+      }
+      const intersection = getSegmentIntersection(p1, p2, o1, o2);
+      if (intersection) {
+        intersections.push(intersection);
+      }
+    }
+  }
+  return intersections;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts
+var EPS4 = 1e-6;
+var isVertical2 = (a, b, eps = EPS4) => Math.abs(a.x - b.x) < eps;
+var generateLShapeRerouteCandidates = ({
+  lShape,
+  rectangle,
+  padding = 0.5,
+  interactionPoint1,
+  interactionPoint2
+}) => {
+  const { p1, p2, p3 } = lShape;
+  const { x, y, width, height } = rectangle;
+  let c2;
+  let i1_padded = interactionPoint1;
+  let i2_padded = interactionPoint2;
+  if (Math.abs(p2.x - x) < EPS4 && Math.abs(p2.y - (y + height)) < EPS4) {
+    c2 = { x: x + width + padding, y: y - padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
+    }
+  } else if (Math.abs(p2.x - (x + width)) < EPS4 && Math.abs(p2.y - (y + height)) < EPS4) {
+    c2 = { x: x - padding, y: y - padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y - padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
+    }
+  } else if (Math.abs(p2.x - x) < EPS4 && Math.abs(p2.y - y) < EPS4) {
+    c2 = { x: x + width + padding, y: y + height + padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x + padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
+    }
+  } else if (Math.abs(p2.x - (x + width)) < EPS4 && Math.abs(p2.y - y) < EPS4) {
+    c2 = { x: x - padding, y: y + height + padding };
+    if (isVertical2(p1, p2)) {
+      i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
+    } else {
+      i1_padded = { x: interactionPoint1.x - padding, y: interactionPoint1.y };
+    }
+    if (isVertical2(p2, p3)) {
+      i2_padded = { x: interactionPoint2.x, y: interactionPoint2.y + padding };
+    } else {
+      i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
+    }
+  } else {
+    return [];
+  }
+  return [[i1_padded, c2, i2_padded]];
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/isPathColliding.ts
+import { getSegmentIntersection as getSegmentIntersection2 } from "@tscircuit/math-utils/line-intersections";
+var isPathColliding = (path, allTraces, traceIdToExclude) => {
+  if (path.length < 2) {
+    return { isColliding: false };
+  }
+  for (let i = 0; i < path.length - 1; i++) {
+    const pathSegP1 = path[i];
+    const pathSegQ1 = path[i + 1];
+    for (const existingTrace of allTraces) {
+      if (existingTrace.mspPairId === traceIdToExclude) {
+        continue;
+      }
+      for (let j = 0; j < existingTrace.tracePath.length - 1; j++) {
+        const existingSegP2 = existingTrace.tracePath[j];
+        const existingSegQ2 = existingTrace.tracePath[j + 1];
+        const intersectionPoint = getSegmentIntersection2(
+          pathSegP1,
+          pathSegQ1,
+          existingSegP2,
+          existingSegQ2
+        );
+        if (intersectionPoint) {
+          return {
+            isColliding: true,
+            collidingTraceId: existingTrace.mspPairId,
+            collisionPoint: intersectionPoint
+          };
+        }
+      }
+    }
+  }
+  return { isColliding: false };
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/generateRectangleCandidates.ts
+var generateRectangleCandidates = (intersections1, intersections2) => {
+  const rectangleCandidates = [];
+  for (const p1 of intersections1) {
+    for (const p2 of intersections2) {
+      const minX = Math.min(p1.x, p2.x);
+      const minY = Math.min(p1.y, p2.y);
+      const maxX = Math.max(p1.x, p2.x);
+      const maxY = Math.max(p1.y, p2.y);
+      const width = maxX - minX;
+      const height = maxY - minY;
+      if (width > 1e-6 && height > 1e-6) {
+        rectangleCandidates.push({
+          rect: {
+            x: minX,
+            y: minY,
+            width,
+            height
+          },
+          i1: p1,
+          i2: p2
+        });
+      }
+    }
+  }
+  return rectangleCandidates;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeLSapes.ts
+var visualizeLSapes = (lShapes) => {
+  const graphics = { circles: [], lines: [] };
+  const lShapesArray = Array.isArray(lShapes) ? lShapes : [lShapes];
+  for (const lShape of lShapesArray) {
+    graphics.circles.push({
+      center: {
+        x: lShape.p2.x,
+        y: lShape.p2.y
+      },
+      radius: 0.01,
+      fill: "blue"
+    });
+    graphics.lines.push({
+      points: [lShape.p1, lShape.p2, lShape.p3],
+      strokeColor: "lightblue"
+    });
+  }
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeIntersectionPoints.ts
+var visualizeIntersectionPoints = (points, color = "red") => {
+  const graphics = { circles: [] };
+  for (const point of points) {
+    graphics.circles.push({
+      center: {
+        x: point.x,
+        y: point.y
+      },
+      radius: 0.01,
+      fill: color
+    });
+  }
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/visualizeTightRectangle.ts
+var visualizeTightRectangle = (rectangle) => {
+  const graphics = { rects: [] };
+  graphics.rects.push({
+    center: {
+      x: rectangle.x + rectangle.width / 2,
+      y: rectangle.y + rectangle.height / 2
+    },
+    width: rectangle.width,
+    height: rectangle.height,
+    stroke: "green"
+  });
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeCandidates.ts
+var visualizeCandidates = (candidates, color = "gray", intersectionPoints = []) => {
+  const graphics = { lines: [], circles: [] };
+  for (const candidate of candidates) {
+    graphics.lines.push({
+      points: candidate,
+      strokeColor: color
+    });
+  }
+  for (const point of intersectionPoints) {
+    graphics.circles.push({
+      center: point,
+      radius: 0.01,
+      // Larger radius for intersection points
+      fill: "green"
+    });
+  }
+  return graphics;
+};
+
+// lib/solvers/TraceCleanupSolver/mergeGraphicsObjects.ts
+var mergeGraphicsObjects = (objects) => {
+  const merged = {
+    lines: [],
+    points: [],
+    rects: [],
+    circles: [],
+    texts: []
+  };
+  for (const obj of objects) {
+    if (!obj) continue;
+    if (obj.lines) merged.lines.push(...obj.lines);
+    if (obj.points) merged.points.push(...obj.points);
+    if (obj.rects) merged.rects.push(...obj.rects);
+    if (obj.circles) merged.circles.push(...obj.circles);
+    if (obj.texts) merged.texts.push(...obj.texts);
+  }
+  return merged;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/visualizeCollision.ts
+var visualizeCollision = (collisionInfo) => {
+  const collisionGraphics = { circles: [] };
+  if (collisionInfo?.isColliding && collisionInfo.collisionPoint) {
+    collisionGraphics.circles.push({
+      center: collisionInfo.collisionPoint,
+      radius: 0.01,
+      fill: "red"
+    });
+  }
+  return collisionGraphics;
+};
+
+// lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts
+var UntangleTraceSubsolver = class extends BaseSolver {
+  input;
+  lShapesToProcess = [];
+  visualizationMode = "l_shapes";
+  currentLShape = null;
+  intersectionPoints = [];
+  tightRectangle = null;
+  candidates = [];
+  bestRoute = null;
+  lastCollision = null;
+  collidingCandidate = null;
+  rectangleCandidates = [];
+  currentRectangleIndex = 0;
+  isInitialStep = true;
+  currentCandidateIndex = 0;
+  lShapeProcessingStep = "idle";
+  lShapeJustProcessed = false;
+  bestRouteFound = null;
+  constructor(solverInput) {
+    super();
+    this.input = solverInput;
+    this.visualizationMode = "l_shapes";
+    for (const trace of this.input.allTraces) {
+      const lShapes = findAllLShapedTurns(trace.tracePath);
+      this.lShapesToProcess.push(
+        ...lShapes.map((l) => ({ ...l, traceId: trace.mspPairId }))
+      );
+    }
+  }
+  _step() {
+    if (this.isInitialStep) {
+      this.isInitialStep = false;
+      return;
+    }
+    if (this.lShapeJustProcessed) {
+      this._resetAfterLShapProcessing();
+      return;
+    }
+    if (this.lShapesToProcess.length === 0 && this.currentLShape === null) {
+      this.solved = true;
+      return;
+    }
+    switch (this.lShapeProcessingStep) {
+      case "idle":
+        this._handleIdleStep();
+        break;
+      case "intersections":
+        this._handleIntersectionsStep();
+        break;
+      case "rectangle_selection":
+        this._handleRectangleSelectionStep();
+        break;
+      case "candidate_evaluation":
+        this._handleCandidateEvaluationStep();
+        break;
+    }
+  }
+  _resetAfterLShapProcessing() {
+    this.lShapeProcessingStep = "idle";
+    this.currentLShape = null;
+    this.currentCandidateIndex = 0;
+    this.lShapeJustProcessed = false;
+    this.visualizationMode = "l_shapes";
+    this.intersectionPoints = [];
+    this.tightRectangle = null;
+    this.candidates = [];
+    this.bestRoute = null;
+    this.lastCollision = null;
+    this.collidingCandidate = null;
+  }
+  _handleIdleStep() {
+    this.currentLShape = this.lShapesToProcess.shift();
+    if (!this.currentLShape) {
+      this.solved = true;
+      return;
+    }
+    this.lShapeProcessingStep = "intersections";
+    this.visualizationMode = "l_shapes";
+  }
+  _handleIntersectionsStep() {
+    if (!this.currentLShape.traceId) {
+      this.lShapeProcessingStep = "idle";
+      return;
+    }
+    const allObstacles = getTraceObstacles(
+      this.input.allTraces,
+      this.currentLShape.traceId
+    );
+    const intersections1 = findIntersectionsWithObstacles(
+      this.currentLShape.p1,
+      this.currentLShape.p2,
+      allObstacles
+    );
+    const intersections2 = findIntersectionsWithObstacles(
+      this.currentLShape.p2,
+      this.currentLShape.p3,
+      allObstacles
+    );
+    this.intersectionPoints = [...intersections1, ...intersections2];
+    if (intersections1.length === 0 || intersections2.length === 0) {
+      this.lShapeProcessingStep = "idle";
+      return;
+    }
+    this.rectangleCandidates = generateRectangleCandidates(
+      intersections1,
+      intersections2
+    );
+    this.currentRectangleIndex = 0;
+    this.lShapeProcessingStep = "rectangle_selection";
+  }
+  _handleRectangleSelectionStep() {
+    if (this.currentRectangleIndex >= this.rectangleCandidates.length) {
+      this.lShapeProcessingStep = "idle";
+      return;
+    }
+    const { rect, i1, i2 } = this.rectangleCandidates[this.currentRectangleIndex];
+    this.tightRectangle = rect;
+    this.candidates = generateLShapeRerouteCandidates({
+      lShape: this.currentLShape,
+      rectangle: this.tightRectangle,
+      padding: 2 * this.input.paddingBuffer,
+      interactionPoint1: i1,
+      interactionPoint2: i2
+    });
+    this.currentCandidateIndex = 0;
+    this.lastCollision = null;
+    this.collidingCandidate = null;
+    this.visualizationMode = "candidates";
+    this.lShapeProcessingStep = "candidate_evaluation";
+  }
+  _handleCandidateEvaluationStep() {
+    this.visualizationMode = "candidates";
+    if (this.bestRouteFound) {
+      this._applyBestRoute(this.bestRouteFound);
+      this.bestRouteFound = null;
+      return;
+    }
+    if (this.currentCandidateIndex >= this.candidates.length) {
+      this.currentRectangleIndex++;
+      this.lShapeProcessingStep = "rectangle_selection";
+      return;
+    }
+    const currentCandidate = this.candidates[this.currentCandidateIndex];
+    const collisionResult = isPathColliding(
+      currentCandidate,
+      this.input.allTraces,
+      this.currentLShape.traceId
+    );
+    if (!collisionResult?.isColliding) {
+      this.bestRouteFound = currentCandidate;
+      this.lastCollision = null;
+      this.collidingCandidate = null;
+    } else {
+      this.lastCollision = collisionResult;
+      this.collidingCandidate = currentCandidate;
+      this.currentCandidateIndex++;
+    }
+  }
+  _applyBestRoute(bestRoute) {
+    this.bestRoute = bestRoute;
+    this.collidingCandidate = null;
+    this.lastCollision = null;
+    const traceIndex = this.input.allTraces.findIndex(
+      (trace) => trace.mspPairId === this.currentLShape.traceId
+    );
+    if (traceIndex !== -1) {
+      const originalTrace = this.input.allTraces[traceIndex];
+      const p2Index = originalTrace.tracePath.findIndex(
+        (p) => p.x === this.currentLShape.p2.x && p.y === this.currentLShape.p2.y
+      );
+      if (p2Index !== -1) {
+        const newTracePath = [
+          ...originalTrace.tracePath.slice(0, p2Index),
+          ...bestRoute,
+          ...originalTrace.tracePath.slice(p2Index + 1)
+        ];
+        this.input.allTraces[traceIndex] = {
+          ...originalTrace,
+          tracePath: newTracePath
+        };
+        this.lShapesToProcess = this.lShapesToProcess.filter(
+          (l) => l.traceId !== this.currentLShape.traceId
+        );
+      }
+    }
+    this.lShapeJustProcessed = true;
+  }
+  getOutput() {
+    return { traces: this.input.allTraces };
+  }
+  visualize() {
+    switch (this.visualizationMode) {
+      case "l_shapes":
+        return visualizeLSapes(this.lShapesToProcess);
+      case "intersection_points":
+        return mergeGraphicsObjects([
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : void 0,
+          visualizeIntersectionPoints(this.intersectionPoints)
+        ]);
+      case "tight_rectangle":
+        return mergeGraphicsObjects([
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : void 0,
+          visualizeIntersectionPoints(this.intersectionPoints),
+          this.tightRectangle ? visualizeTightRectangle(this.tightRectangle) : void 0
+        ]);
+      case "candidates": {
+        if (this.lShapeJustProcessed) {
+          const allTracesGraphics2 = { lines: [] };
+          for (const trace of this.input.allTraces) {
+            const isUpdatedTrace = trace.mspPairId === this.currentLShape?.traceId;
+            for (let i = 0; i < trace.tracePath.length - 1; i++) {
+              allTracesGraphics2.lines.push({
+                points: [trace.tracePath[i], trace.tracePath[i + 1]],
+                strokeColor: isUpdatedTrace ? "green" : "#ccc"
+              });
+            }
+          }
+          return allTracesGraphics2;
+        }
+        const allTracesGraphics = { lines: [] };
+        for (const trace of this.input.allTraces) {
+          for (let i = 0; i < trace.tracePath.length - 1; i++) {
+            allTracesGraphics.lines.push({
+              points: [trace.tracePath[i], trace.tracePath[i + 1]],
+              strokeColor: "#ccc"
+              // Light gray for other traces
+            });
+          }
+        }
+        let candidateToDraw;
+        if (this.bestRouteFound) {
+          candidateToDraw = this.bestRouteFound;
+        } else if (this.lastCollision?.isColliding) {
+          candidateToDraw = this.collidingCandidate ?? void 0;
+        } else {
+          if (this.currentCandidateIndex < this.candidates.length) {
+            candidateToDraw = this.candidates[this.currentCandidateIndex];
+          }
+        }
+        return mergeGraphicsObjects([
+          allTracesGraphics,
+          this.currentLShape ? visualizeLSapes(this.currentLShape) : void 0,
+          this.tightRectangle ? visualizeTightRectangle(this.tightRectangle) : void 0,
+          candidateToDraw ? visualizeCandidates(
+            [candidateToDraw],
+            this.bestRouteFound ? "green" : "blue",
+            this.intersectionPoints
+          ) : void 0,
+          this.lastCollision ? visualizeCollision(this.lastCollision) : void 0
+        ]);
+      }
+      default:
+        return {};
+    }
+  }
+};
+
+// lib/solvers/TraceCleanupSolver/is4PointRectangle.ts
+var is4PointRectangle = (path) => {
+  if (path.length !== 4) return false;
+  const [p0, p1, p2, p3] = path;
+  const isHVHC = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x;
+  const isVHVC = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y;
+  return isHVHC || isVHVC;
+};
+
 // lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts
 var TraceCleanupSolver = class extends BaseSolver {
   input;
   outputTraces;
   traceIdQueue;
   tracesMap;
-  pipelineStep = "minimizing_turns";
+  pipelineStep = "untangling_traces";
   activeTraceId = null;
   // New property
+  activeSubSolver = null;
   constructor(solverInput) {
     super();
     this.input = solverInput;
     this.outputTraces = [...solverInput.allTraces];
     this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]));
-    this.traceIdQueue = Array.from(solverInput.targetTraceIds);
+    this.traceIdQueue = Array.from(
+      solverInput.allTraces.map((e) => e.mspPairId)
+    );
   }
   _step() {
-    if (this.pipelineStep === "minimizing_turns" && this.traceIdQueue.length === 0) {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        const output = this.activeSubSolver.getOutput();
+        this.outputTraces = output.traces;
+        this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]));
+        this.activeSubSolver = null;
+        this.pipelineStep = "minimizing_turns";
+      } else if (this.activeSubSolver.failed) {
+        this.activeSubSolver = null;
+        this.pipelineStep = "minimizing_turns";
+      }
+      return;
+    }
+    switch (this.pipelineStep) {
+      case "untangling_traces":
+        this._runUntangleTracesStep();
+        break;
+      case "minimizing_turns":
+        this._runMinimizeTurnsStep();
+        break;
+      case "balancing_l_shapes":
+        this._runBalanceLShapesStep();
+        break;
+    }
+  }
+  _runUntangleTracesStep() {
+    this.activeSubSolver = new UntangleTraceSubsolver({
+      ...this.input,
+      allTraces: Array.from(this.tracesMap.values())
+    });
+  }
+  _runMinimizeTurnsStep() {
+    if (this.traceIdQueue.length === 0) {
       this.pipelineStep = "balancing_l_shapes";
-      this.traceIdQueue = Array.from(this.input.targetTraceIds);
+      this.traceIdQueue = Array.from(
+        this.input.allTraces.map((e) => e.mspPairId)
+      );
+      return;
     }
-    if (this.pipelineStep === "balancing_l_shapes" && this.traceIdQueue.length === 0) {
+    this._processTrace("minimizing_turns");
+  }
+  _runBalanceLShapesStep() {
+    if (this.traceIdQueue.length === 0) {
       this.solved = true;
       return;
     }
+    this._processTrace("balancing_l_shapes");
+  }
+  _processTrace(step) {
     const targetMspConnectionPairId = this.traceIdQueue.shift();
     this.activeTraceId = targetMspConnectionPairId;
     const originalTrace = this.tracesMap.get(targetMspConnectionPairId);
-    const { tracePath } = originalTrace;
-    const is4PointRectangle = (path) => {
-      if (path.length !== 4) return false;
-      const [p0, p1, p2, p3] = path;
-      const isHVHC = p0.y === p1.y && p1.x === p2.x && p2.y === p3.y && p0.x === p3.x;
-      const isVHVC = p0.x === p1.x && p1.y === p2.y && p2.x === p3.x && p0.y === p3.y;
-      return isHVHC || isVHVC;
-    };
-    if (is4PointRectangle(tracePath)) {
+    if (is4PointRectangle(originalTrace.tracePath)) {
       return;
     }
     const allTraces = Array.from(this.tracesMap.values());
     let updatedTrace;
-    if (this.pipelineStep === "minimizing_turns") {
+    if (step === "minimizing_turns") {
       updatedTrace = minimizeTurnsWithFilteredLabels({
         ...this.input,
         targetMspConnectionPairId,
@@ -3617,6 +4539,9 @@ var TraceCleanupSolver = class extends BaseSolver {
     };
   }
   visualize() {
+    if (this.activeSubSolver) {
+      return this.activeSubSolver.visualize();
+    }
     const graphics = visualizeInputProblem(this.input.inputProblem, {
       chipAlpha: 0.1,
       connectionAlpha: 0.1
@@ -3773,7 +4698,6 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: instance.inputProblem,
           allTraces: traces,
-          targetTraceIds: new Set(traces.map((t) => t.mspPairId)),
           allLabelPlacements: labelMergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
           paddingBuffer: 0.1