@tscircuit/schematic-trace-solver 0.0.45 → 0.0.46

package/.github/workflows/bun-formatcheck.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
 
       - name: Install dependencies
         run: bun install

package/.github/workflows/bun-pver-release.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
       - uses: actions/setup-node@v3
         with:
           node-version: 20

package/.github/workflows/bun-test.yml

@@ -19,7 +19,7 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
 
       - name: Install dependencies
         run: bun install

package/.github/workflows/bun-typecheck.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
 
       - name: Install dependencies
         run: bun i

package/dist/index.d.ts

@@ -396,13 +396,20 @@ interface LabelMergingSolverOutput {
 }
 /**
  * Merges multiple net labels into a single, larger label if they are on the
- * same side of the same chip, reducing schematic clutter.
+ * same side of the same chip and physically adjacent.
  */
 declare class MergedNetLabelObstacleSolver extends BaseSolver {
     private input;
     private output;
     private inputProblem;
     private traces;
+    private pipelineStep;
+    private filteredLabels;
+    private labelGroups;
+    private groupKeysToProcess;
+    private finalPlacements;
+    private mergedLabelNetIdMap;
+    private activeMergingGroupKey;
     constructor(solverInput: LabelMergingSolverInput);
     _step(): void;
     getOutput(): LabelMergingSolverOutput;
@@ -436,7 +443,8 @@ declare class SingleOverlapSolver extends BaseSolver {
 interface OverlapCollectionSolverInput {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
-    netLabelPlacements: NetLabelPlacement[];
+    initialNetLabelPlacements: NetLabelPlacement[];
+    mergedNetLabelPlacements: NetLabelPlacement[];
     mergedLabelNetIdMap: Record<string, Set<string>>;
 }
 /**
@@ -445,7 +453,8 @@ interface OverlapCollectionSolverInput {
  */
 declare class OverlapAvoidanceStepSolver extends BaseSolver {
     inputProblem: InputProblem;
-    netLabelPlacements: NetLabelPlacement[];
+    initialNetLabelPlacements: NetLabelPlacement[];
+    mergedNetLabelPlacements: NetLabelPlacement[];
     mergedLabelNetIdMap: Record<string, Set<string>>;
     allTraces: SolvedTracePath[];
     modifiedTraces: SolvedTracePath[];
@@ -454,6 +463,8 @@ declare class OverlapAvoidanceStepSolver extends BaseSolver {
     activeSubSolver: SingleOverlapSolver | null;
     private overlapQueue;
     private recentlyFailed;
+    private currentlyProcessingOverlap;
+    private decomposedChildLabels;
     constructor(solverInput: OverlapCollectionSolverInput);
     _step(): void;
     getOutput(): {
@@ -469,8 +480,21 @@ interface TraceLabelOverlapAvoidanceSolverInput {
     netLabelPlacements: NetLabelPlacement[];
 }
 /**
- * This solver is a pipeline that runs a series of sub-solvers to resolve
- * trace-label overlaps and clean up the resulting traces.
+ * A pipeline solver responsible for resolving overlaps between schematic traces and net labels.
+ *
+ * This solver orchestrates a sequence of sub-solvers to achieve its goal:
+ * 1. **MergedNetLabelObstacleSolver**: This solver first merges labels that are
+ *    close to each other to form larger "obstacle" groups. This simplifies the
+ *    problem by reducing the number of individual obstacles the traces need to avoid.
+ * 2. **OverlapAvoidanceStepSolver**: This solver then takes the output of the merging
+ *    step and iteratively attempts to reroute traces to avoid the merged label obstacles.
+ *    It handles one overlap at a time, making it a step-by-step process.
+ *
+ * The final output is a set of modified traces that have been rerouted to avoid
+ * labels, and the set of merged labels that were used as obstacles.
+ *
+ * @param {TraceLabelOverlapAvoidanceSolverInput} solverInput - The input for the solver,
+ *   containing the initial traces, label placements, and the input problem definition.
  */
 declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     inputProblem: InputProblem;

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;
@@ -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);