@tscircuit/schematic-trace-solver 0.0.45 → 0.0.47

package/dist/index.js

@@ -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;
@@ -2521,73 +2649,106 @@ var generateFourPointDetourCandidates = ({
   paddingBuffer,
   detourCount
 }) => {
-  let collidingSegIndex = -1;
-  for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
-    if (segmentIntersectsRect(
-      initialTrace.tracePath[i],
-      initialTrace.tracePath[i + 1],
-      labelBounds
-    )) {
-      collidingSegIndex = i;
-      break;
+  const isMergedLabel = label.globalConnNetId.startsWith("merged-group-");
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding
+  };
+  let entryPoint, exitPoint;
+  let entryIndex, exitIndex;
+  const isPointInRect = (p) => p.x >= paddedLabelBounds.minX && p.x <= paddedLabelBounds.maxX && p.y >= paddedLabelBounds.minY && p.y <= paddedLabelBounds.maxY;
+  if (isMergedLabel) {
+    let firstInsideIndex = -1;
+    for (let i = 0; i < initialTrace.tracePath.length; i++) {
+      if (isPointInRect(initialTrace.tracePath[i])) {
+        firstInsideIndex = i;
+        break;
+      }
+    }
+    if (firstInsideIndex === -1) return [];
+    entryIndex = Math.max(0, firstInsideIndex - 1);
+    entryPoint = initialTrace.tracePath[entryIndex];
+    let firstOutsideIndex = -1;
+    for (let i = firstInsideIndex; i < initialTrace.tracePath.length; i++) {
+      if (!isPointInRect(initialTrace.tracePath[i])) {
+        firstOutsideIndex = i;
+        break;
+      }
+    }
+    if (firstOutsideIndex === -1) {
+      exitIndex = initialTrace.tracePath.length - 1;
+    } else {
+      exitIndex = firstOutsideIndex;
     }
+    exitPoint = initialTrace.tracePath[exitIndex];
+  } else {
+    let collidingSegIndex = -1;
+    for (let i = 0; i < initialTrace.tracePath.length - 1; i++) {
+      if (segmentIntersectsRect(
+        initialTrace.tracePath[i],
+        initialTrace.tracePath[i + 1],
+        { ...paddedLabelBounds, chipId: "temp-obstacle" }
+      )) {
+        collidingSegIndex = i;
+        break;
+      }
+    }
+    if (collidingSegIndex === -1) return [];
+    entryIndex = collidingSegIndex;
+    exitIndex = collidingSegIndex + 1;
+    entryPoint = initialTrace.tracePath[entryIndex];
+    exitPoint = initialTrace.tracePath[exitIndex];
   }
-  if (collidingSegIndex === -1) return [];
-  const pA = initialTrace.tracePath[collidingSegIndex];
-  const pB = initialTrace.tracePath[collidingSegIndex + 1];
-  if (!pA || !pB) return [];
+  if (!entryPoint || !exitPoint || entryIndex >= exitIndex) return [];
   const candidateDetours = [];
-  const paddedLabelBounds = getRectBounds(
-    label.center,
-    label.width,
-    label.height
-  );
-  const effectivePadding = paddingBuffer + detourCount * paddingBuffer;
-  if (isVertical(pA, pB)) {
-    const xCandidates = [
-      paddedLabelBounds.maxX + effectivePadding,
-      paddedLabelBounds.minX - effectivePadding
-    ];
-    for (const newX of xCandidates) {
+  const dx = exitPoint.x - entryPoint.x;
+  const dy = exitPoint.y - entryPoint.y;
+  if (Math.abs(dx) > Math.abs(dy)) {
+    const yCandidates = [paddedLabelBounds.maxY, paddedLabelBounds.minY];
+    for (const newY of yCandidates) {
       candidateDetours.push(
-        pB.y > pA.y ? [
-          { x: pA.x, y: paddedLabelBounds.minY - effectivePadding },
-          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-          { x: pB.x, y: paddedLabelBounds.maxY + effectivePadding }
+        dx > 0 ? [
+          { x: paddedLabelBounds.minX, y: entryPoint.y },
+          { x: paddedLabelBounds.minX, y: newY },
+          { x: paddedLabelBounds.maxX, y: newY },
+          { x: paddedLabelBounds.maxX, y: exitPoint.y }
         ] : [
-          { x: pA.x, y: paddedLabelBounds.maxY + effectivePadding },
-          { x: newX, y: paddedLabelBounds.maxY + effectivePadding },
-          { x: newX, y: paddedLabelBounds.minY - effectivePadding },
-          { x: pB.x, y: paddedLabelBounds.minY - effectivePadding }
+          // Right-to-left
+          { x: paddedLabelBounds.maxX, y: entryPoint.y },
+          { x: paddedLabelBounds.maxX, y: newY },
+          { x: paddedLabelBounds.minX, y: newY },
+          { x: paddedLabelBounds.minX, y: exitPoint.y }
         ]
       );
     }
   } else {
-    const yCandidates = [
-      paddedLabelBounds.maxY + effectivePadding,
-      paddedLabelBounds.minY - effectivePadding
-    ];
-    for (const newY of yCandidates) {
+    const xCandidates = [paddedLabelBounds.maxX, paddedLabelBounds.minX];
+    for (const newX of xCandidates) {
       candidateDetours.push(
-        pB.x > pA.x ? [
-          { x: paddedLabelBounds.minX - effectivePadding, y: pA.y },
-          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-          { x: paddedLabelBounds.maxX + effectivePadding, y: pB.y }
+        dy > 0 ? [
+          { x: entryPoint.x, y: paddedLabelBounds.minY },
+          { x: newX, y: paddedLabelBounds.minY },
+          { x: newX, y: paddedLabelBounds.maxY },
+          { x: exitPoint.x, y: paddedLabelBounds.maxY }
         ] : [
-          { x: paddedLabelBounds.maxX + effectivePadding, y: pA.y },
-          { x: paddedLabelBounds.maxX + effectivePadding, y: newY },
-          { x: paddedLabelBounds.minX - effectivePadding, y: newY },
-          { x: paddedLabelBounds.minX - effectivePadding, y: pB.y }
+          // Bottom-to-top
+          { x: entryPoint.x, y: paddedLabelBounds.maxY },
+          { x: newX, y: paddedLabelBounds.maxY },
+          { x: newX, y: paddedLabelBounds.minY },
+          { x: exitPoint.x, y: paddedLabelBounds.minY }
         ]
       );
     }
   }
   return candidateDetours.map((detourPoints) => [
-    ...initialTrace.tracePath.slice(0, collidingSegIndex + 1),
+    ...initialTrace.tracePath.slice(0, entryIndex),
+    entryPoint,
     ...detourPoints,
-    ...initialTrace.tracePath.slice(collidingSegIndex + 1)
+    exitPoint,
+    ...initialTrace.tracePath.slice(exitIndex + 1)
   ]);
 };
 
@@ -2631,13 +2792,12 @@ var generateRerouteCandidates = ({
   if (trace.globalConnNetId === label.globalConnNetId) {
     return [initialTrace.tracePath];
   }
-  const labelPadding = paddingBuffer;
   const labelBoundsRaw = getRectBounds(label.center, label.width, label.height);
   const labelBounds = {
-    minX: labelBoundsRaw.minX - labelPadding,
-    minY: labelBoundsRaw.minY - labelPadding,
-    maxX: labelBoundsRaw.maxX + labelPadding,
-    maxY: labelBoundsRaw.maxY + labelPadding,
+    minX: labelBoundsRaw.minX,
+    minY: labelBoundsRaw.minY,
+    maxX: labelBoundsRaw.maxX,
+    maxY: labelBoundsRaw.maxY,
     chipId: `netlabel-${label.netId}`
   };
   const fourPointCandidates = generateFourPointDetourCandidates({
@@ -2663,6 +2823,7 @@ var generateRerouteCandidates = ({
 };
 
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
+var MAX_TRIES = 5;
 var SingleOverlapSolver = class extends BaseSolver {
   queuedCandidatePaths;
   solvedTracePath = null;
@@ -2670,13 +2831,17 @@ var SingleOverlapSolver = class extends BaseSolver {
   problem;
   obstacles;
   label;
+  _tried = 0;
   constructor(solverInput) {
     super();
     this.initialTrace = solverInput.trace;
     this.problem = solverInput.problem;
     this.label = solverInput.label;
+    const effectivePadding = solverInput.paddingBuffer + solverInput.detourCount * solverInput.paddingBuffer;
     const candidates = generateRerouteCandidates({
-      ...solverInput
+      ...solverInput,
+      paddingBuffer: effectivePadding
+      // Use the calculated, larger padding
     });
     const getPathLength = (pts) => {
       let len = 0;
@@ -2693,10 +2858,11 @@ var SingleOverlapSolver = class extends BaseSolver {
     this.obstacles = getObstacleRects(this.problem);
   }
   _step() {
-    if (this.queuedCandidatePaths.length === 0) {
+    if (this.queuedCandidatePaths.length === 0 || this._tried >= MAX_TRIES) {
       this.failed = true;
       return;
     }
+    this._tried++;
     const nextCandidatePath = this.queuedCandidatePaths.shift();
     const simplifiedPath = simplifyPath(nextCandidatePath);
     if (!isPathCollidingWithObstacles(simplifiedPath, this.obstacles)) {
@@ -2738,26 +2904,92 @@ var SingleOverlapSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/doesTraceStartOrEndInLabel.ts
+var doesTraceStartOrEndInLabel = ({ trace, label }) => {
+  if (trace.tracePath.length < 2) {
+    return false;
+  }
+  const firstSegmentTrace = {
+    ...trace,
+    tracePath: [trace.tracePath[0], trace.tracePath[1]]
+  };
+  const firstSegmentOverlap = detectTraceLabelOverlap({
+    traces: [firstSegmentTrace],
+    netLabels: [label]
+  });
+  if (firstSegmentOverlap.length > 0) {
+    return true;
+  }
+  if (trace.tracePath.length > 2) {
+    const lastPoint = trace.tracePath[trace.tracePath.length - 1];
+    const secondToLastPoint = trace.tracePath[trace.tracePath.length - 2];
+    const lastSegmentTrace = {
+      ...trace,
+      tracePath: [secondToLastPoint, lastPoint]
+    };
+    const lastSegmentOverlap = detectTraceLabelOverlap({
+      traces: [lastSegmentTrace],
+      netLabels: [label]
+    });
+    if (lastSegmentOverlap.length > 0) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// 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 = [];
-  detourCountByLabel = {};
   PADDING_BUFFER = 0.1;
+  detourCounts = /* @__PURE__ */ new Map();
   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];
+    this.detourCounts = solverInput.detourCounts;
   }
   _step() {
+    this.currentlyProcessingOverlap = null;
+    this.decomposedChildLabels = null;
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
       if (this.activeSubSolver.solved) {
@@ -2777,18 +3009,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,28 +3031,100 @@ 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 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 detourCount2 = this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0;
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            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 && doesTraceStartOrEndInLabel({ trace: traceToFix, 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 detourCount2 = this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0;
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            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 detourCount = this.detourCounts.get(labelToAvoid.globalConnNetId) ?? 0;
+      this.detourCounts.set(labelToAvoid.globalConnNetId, detourCount + 1);
+      this.activeSubSolver = new SingleOverlapSolver({
+        trace: traceToFix,
+        label: labelToAvoid,
+        problem: this.inputProblem,
+        paddingBuffer: this.PADDING_BUFFER,
+        detourCount
+      });
     }
   }
   getOutput() {
     return {
       allTraces: this.allTraces,
-      modifiedTraces: this.modifiedTraces
+      modifiedTraces: this.modifiedTraces,
+      detourCounts: this.detourCounts
     };
   }
   visualize() {
@@ -2840,6 +3139,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;
   }
 };
@@ -2847,74 +3177,101 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts
 var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
   inputProblem;
-  traces;
   netLabelPlacements;
-  // sub-solver instances
+  unprocessedTraces = [];
+  cleanTraces = [];
+  subSolvers = [];
+  phase = "searching_for_overlaps";
+  detourCounts = /* @__PURE__ */ new Map();
   labelMergingSolver;
-  overlapAvoidanceSolver;
-  pipelineStepIndex = 0;
   constructor(solverInput) {
     super();
     this.inputProblem = solverInput.inputProblem;
-    this.traces = solverInput.traces;
+    this.unprocessedTraces = [...solverInput.traces];
     this.netLabelPlacements = solverInput.netLabelPlacements;
+    this.cleanTraces = [];
+    this.subSolvers = [];
   }
   _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;
+    if (this.phase === "searching_for_overlaps") {
+      if (this.unprocessedTraces.length === 0) {
+        console.log(
+          `Dispatch phase complete. Created ${this.subSolvers.length} sub-solvers.`
+        );
+        this.phase = "fixing_overlaps";
+        return;
       }
-      return;
-    }
-    switch (this.pipelineStepIndex) {
-      case 0:
-        this.labelMergingSolver = new MergedNetLabelObstacleSolver({
-          netLabelPlacements: this.netLabelPlacements,
+      const currentTargetTrace = this.unprocessedTraces.shift();
+      const localOverlaps = detectTraceLabelOverlap({
+        traces: [currentTargetTrace],
+        netLabels: this.netLabelPlacements
+      });
+      if (localOverlaps.length === 0) {
+        this.cleanTraces.push(currentTargetTrace);
+      } else {
+        const collidingLabels = localOverlaps.map((o) => o.label);
+        const labelMerger = new MergedNetLabelObstacleSolver({
+          netLabelPlacements: collidingLabels,
           inputProblem: this.inputProblem,
-          traces: this.traces
+          traces: [currentTargetTrace]
         });
-        this.activeSubSolver = this.labelMergingSolver;
-        break;
-      case 1:
-        this.overlapAvoidanceSolver = new OverlapAvoidanceStepSolver({
+        labelMerger.solve();
+        const mergingOutput = labelMerger.getOutput();
+        const subSolver = new OverlapAvoidanceStepSolver({
           inputProblem: this.inputProblem,
-          traces: this.traces,
-          netLabelPlacements: this.labelMergingSolver.getOutput().netLabelPlacements,
-          mergedLabelNetIdMap: this.labelMergingSolver.getOutput().mergedLabelNetIdMap
+          traces: [currentTargetTrace],
+          initialNetLabelPlacements: this.netLabelPlacements,
+          mergedNetLabelPlacements: mergingOutput.netLabelPlacements,
+          mergedLabelNetIdMap: mergingOutput.mergedLabelNetIdMap,
+          detourCounts: this.detourCounts
         });
-        this.activeSubSolver = this.overlapAvoidanceSolver;
-        break;
-      default:
+        this.subSolvers.push(subSolver);
+      }
+    } else if (this.phase === "fixing_overlaps") {
+      if (this.subSolvers.every((s) => s.solved || s.failed)) {
+        console.log("All sub-solvers finished.");
+        if (!this.labelMergingSolver) {
+          this.labelMergingSolver = new MergedNetLabelObstacleSolver({
+            netLabelPlacements: this.netLabelPlacements,
+            inputProblem: this.inputProblem,
+            traces: this.getOutput().traces
+          });
+          this.labelMergingSolver.solve();
+        }
         this.solved = true;
-        break;
+        return;
+      }
+      for (const solver of this.subSolvers) {
+        if (!solver.solved && !solver.failed) {
+          solver.step();
+        }
+      }
     }
   }
   getOutput() {
+    const solvedTraces = this.subSolvers.flatMap((s) => s.getOutput().allTraces);
     return {
-      traces: this.overlapAvoidanceSolver?.getOutput().allTraces ?? this.traces,
+      traces: [...this.cleanTraces, ...solvedTraces],
       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) {
+    for (const trace of this.cleanTraces) {
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "purple"
       });
     }
-    for (const label of output.netLabelPlacements) {
+    for (const solver of this.subSolvers) {
+      const solverGraphics = solver.visualize();
+      graphics.lines.push(...solverGraphics.lines ?? []);
+      graphics.rects.push(...solverGraphics.rects ?? []);
+      graphics.points.push(...solverGraphics.points ?? []);
+    }
+    for (const label of this.netLabelPlacements) {
       const color = getColorFromString(label.globalConnNetId, 0.3);
       graphics.rects.push({
         center: label.center,
@@ -3006,7 +3363,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 +3404,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);