@tscircuit/schematic-trace-solver 0.0.55 → 0.0.56

package/dist/index.d.ts

@@ -820,6 +820,32 @@ declare class TraceAnchoredNetLabelOverlapSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+interface NetLabelTraceCollisionSolverParams {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+declare class NetLabelTraceCollisionSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    outputTraces: SolvedTracePath[];
+    outputNetLabelPlacements: NetLabelPlacement[];
+    activeSubSolver: SingleOverlapSolver | null;
+    private recentlyFailed;
+    private detourCounts;
+    private currentOverlap;
+    constructor(params: NetLabelTraceCollisionSolverParams);
+    getConstructorParams(): ConstructorParameters<typeof NetLabelTraceCollisionSolver>[0];
+    _step(): void;
+    getOutput(): {
+        traces: SolvedTracePath[];
+        netLabelPlacements: NetLabelPlacement[];
+    };
+    private getOverlapKey;
+    visualize(): GraphicsObject;
+}
+
 /**
  * Pipeline solver that runs a series of solvers to find the best schematic layout.
  * Coordinates the entire layout process from chip partitioning through final packing.
@@ -849,12 +875,13 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     availableNetOrientationSolver?: AvailableNetOrientationSolver;
     vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver;
     traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver;
+    netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof VccNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof VccNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver>)[];
     constructor(inputProblem: InputProblem);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
     currentPipelineStepIndex: number;

package/dist/index.js

@@ -7150,6 +7150,214 @@ var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts
+function buildMergedObstacleLabel(seedLabel, allLabels) {
+  const TOUCH_MARGIN = 0.01;
+  const getBounds3 = (l) => getRectBounds(l.center, l.width, l.height);
+  const touches = (a, b) => {
+    const ba = getBounds3(a);
+    const bb = getBounds3(b);
+    return ba.minX <= bb.maxX + TOUCH_MARGIN && ba.maxX >= bb.minX - TOUCH_MARGIN && ba.minY <= bb.maxY + TOUCH_MARGIN && ba.maxY >= bb.minY - TOUCH_MARGIN;
+  };
+  const group = /* @__PURE__ */ new Set([seedLabel]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const l of allLabels) {
+      if (group.has(l)) continue;
+      if ([...group].some((g) => touches(g, l))) {
+        group.add(l);
+        changed = true;
+      }
+    }
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const l of group) {
+    const b = getBounds3(l);
+    if (b.minX < minX) minX = b.minX;
+    if (b.minY < minY) minY = b.minY;
+    if (b.maxX > maxX) maxX = b.maxX;
+    if (b.maxY > maxY) maxY = b.maxY;
+  }
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const w = maxX - minX;
+  const h = maxY - minY;
+  return {
+    ...seedLabel,
+    center: { x: cx, y: cy },
+    width: w,
+    height: h
+  };
+}
+function detectInnerTraceLabelOverlaps(traces, labels) {
+  const overlaps = [];
+  for (const trace of traces) {
+    for (const label of labels) {
+      if (trace.globalConnNetId === label.globalConnNetId) continue;
+      const bounds = getRectBounds(label.center, label.width, label.height);
+      const path = trace.tracePath;
+      const innerStart = 1;
+      const innerEnd = path.length - 2;
+      for (let i = innerStart; i < innerEnd; i++) {
+        if (segmentIntersectsRect2(path[i], path[i + 1], bounds)) {
+          overlaps.push({ trace, label });
+          break;
+        }
+      }
+    }
+  }
+  return overlaps;
+}
+var PADDING_BUFFER = 0.1;
+var MAX_DETOUR_ATTEMPTS = 3;
+var NetLabelTraceCollisionSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  outputTraces;
+  outputNetLabelPlacements;
+  activeSubSolver = null;
+  recentlyFailed = /* @__PURE__ */ new Set();
+  detourCounts = /* @__PURE__ */ new Map();
+  currentOverlap = null;
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.traces = params.traces;
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputTraces = [...params.traces];
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+  }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath;
+        if (solvedPath) {
+          const idx = this.outputTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver.initialTrace.mspPairId
+          );
+          if (idx !== -1) {
+            this.outputTraces[idx] = {
+              ...this.outputTraces[idx],
+              tracePath: solvedPath
+            };
+          }
+        }
+        this.activeSubSolver = null;
+        this.currentOverlap = null;
+      } else if (this.activeSubSolver.failed) {
+        const key = this.getOverlapKey(
+          this.activeSubSolver.initialTrace,
+          this.activeSubSolver.label
+        );
+        this.recentlyFailed.add(key);
+        this.activeSubSolver = null;
+        this.currentOverlap = null;
+      }
+      return;
+    }
+    const overlaps = detectInnerTraceLabelOverlaps(
+      this.outputTraces,
+      this.outputNetLabelPlacements
+    );
+    const actionable = overlaps.filter((o) => {
+      const key = this.getOverlapKey(o.trace, o.label);
+      return !this.recentlyFailed.has(key);
+    });
+    if (actionable.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const next = actionable[0];
+    const traceToFix = this.outputTraces.find(
+      (t) => t.mspPairId === next.trace.mspPairId
+    );
+    this.currentOverlap = next;
+    const mergedLabel = buildMergedObstacleLabel(
+      next.label,
+      this.outputNetLabelPlacements.filter(
+        (l) => l.globalConnNetId !== traceToFix.globalConnNetId
+      )
+    );
+    const mergeKey = `${next.trace.mspPairId}::merged::${mergedLabel.center.x},${mergedLabel.center.y},${mergedLabel.width},${mergedLabel.height}`;
+    const detourCount = this.detourCounts.get(mergeKey) ?? 0;
+    if (detourCount >= MAX_DETOUR_ATTEMPTS) {
+      this.recentlyFailed.add(this.getOverlapKey(next.trace, next.label));
+      this.currentOverlap = null;
+      return;
+    }
+    this.detourCounts.set(mergeKey, detourCount + 1);
+    this.activeSubSolver = new SingleOverlapSolver({
+      trace: traceToFix,
+      label: mergedLabel,
+      problem: this.inputProblem,
+      paddingBuffer: PADDING_BUFFER,
+      detourCount
+    });
+  }
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements
+    };
+  }
+  getOverlapKey(trace, label) {
+    return `${trace.mspPairId}::${label.globalConnNetId}`;
+  }
+  visualize() {
+    if (this.activeSubSolver) return this.activeSubSolver.visualize();
+    const graphics = visualizeInputProblem(this.inputProblem);
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.rects) graphics.rects = [];
+    if (!graphics.points) graphics.points = [];
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const label of this.outputNetLabelPlacements) {
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+      });
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9)
+      });
+    }
+    if (this.currentOverlap) {
+      graphics.lines.push({
+        points: this.currentOverlap.trace.tracePath,
+        strokeColor: "red"
+      });
+      graphics.rects.push({
+        center: this.currentOverlap.label.center,
+        width: this.currentOverlap.label.width,
+        height: this.currentOverlap.label.height,
+        fill: "rgba(255,0,0,0.3)",
+        strokeColor: "red"
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -7174,6 +7382,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   availableNetOrientationSolver;
   vccNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
+  netLabelTraceCollisionSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -7354,6 +7563,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           netLabelPlacements: instance.vccNetLabelCornerPlacementSolver.outputNetLabelPlacements
         }
       ]
+    ),
+    definePipelineStep(
+      "netLabelTraceCollisionSolver",
+      NetLabelTraceCollisionSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.availableNetOrientationSolver.traces,
+          netLabelPlacements: instance.traceAnchoredNetLabelOverlapSolver.outputNetLabelPlacements
+        }
+      ]
     )
   ];
   constructor(inputProblem) {

package/lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts

@@ -0,0 +1,294 @@
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import type { InputProblem } from "lib/types/InputProblem"
+
+/**
+ * Merges all labels that touch/overlap with each other (transitively) around
+ * a seed label into a single bounding-box label. This prevents the situation
+ * where fixing one label collision re-routes the trace into an adjacent label.
+ */
+function buildMergedObstacleLabel(
+  seedLabel: NetLabelPlacement,
+  allLabels: NetLabelPlacement[],
+): NetLabelPlacement {
+  const TOUCH_MARGIN = 0.01
+
+  const getBounds = (l: NetLabelPlacement) =>
+    getRectBounds(l.center, l.width, l.height)
+
+  const touches = (a: NetLabelPlacement, b: NetLabelPlacement) => {
+    const ba = getBounds(a)
+    const bb = getBounds(b)
+    return (
+      ba.minX <= bb.maxX + TOUCH_MARGIN &&
+      ba.maxX >= bb.minX - TOUCH_MARGIN &&
+      ba.minY <= bb.maxY + TOUCH_MARGIN &&
+      ba.maxY >= bb.minY - TOUCH_MARGIN
+    )
+  }
+
+  const group = new Set<NetLabelPlacement>([seedLabel])
+  let changed = true
+  while (changed) {
+    changed = false
+    for (const l of allLabels) {
+      if (group.has(l)) continue
+      if ([...group].some((g) => touches(g, l))) {
+        group.add(l)
+        changed = true
+      }
+    }
+  }
+
+  let minX = Infinity,
+    minY = Infinity,
+    maxX = -Infinity,
+    maxY = -Infinity
+  for (const l of group) {
+    const b = getBounds(l)
+    if (b.minX < minX) minX = b.minX
+    if (b.minY < minY) minY = b.minY
+    if (b.maxX > maxX) maxX = b.maxX
+    if (b.maxY > maxY) maxY = b.maxY
+  }
+
+  const cx = (minX + maxX) / 2
+  const cy = (minY + maxY) / 2
+  const w = maxX - minX
+  const h = maxY - minY
+
+  return {
+    ...seedLabel,
+    center: { x: cx, y: cy },
+    width: w,
+    height: h,
+  }
+}
+
+interface TraceInnerLabelOverlap {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+}
+
+/**
+ * Detects overlaps where a trace's INTERIOR (non-endpoint) segments cross a label.
+ * Traces are allowed to boundary a label at their endpoints (pin locations),
+ * just not allowed to cross through it in the middle.
+ */
+function detectInnerTraceLabelOverlaps(
+  traces: SolvedTracePath[],
+  labels: NetLabelPlacement[],
+): TraceInnerLabelOverlap[] {
+  const overlaps: TraceInnerLabelOverlap[] = []
+  for (const trace of traces) {
+    for (const label of labels) {
+      if (trace.globalConnNetId === label.globalConnNetId) continue
+      const bounds = getRectBounds(label.center, label.width, label.height)
+      const path = trace.tracePath
+      // Skip first and last segments — trace endpoints (pins) may legitimately
+      // sit inside or adjacent to labels of neighbouring nets.
+      const innerStart = 1
+      const innerEnd = path.length - 2
+      for (let i = innerStart; i < innerEnd; i++) {
+        if (segmentIntersectsRect(path[i]!, path[i + 1]!, bounds)) {
+          overlaps.push({ trace, label })
+          break
+        }
+      }
+    }
+  }
+  return overlaps
+}
+
+export interface NetLabelTraceCollisionSolverParams {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+const PADDING_BUFFER = 0.1
+const MAX_DETOUR_ATTEMPTS = 3
+
+export class NetLabelTraceCollisionSolver extends BaseSolver {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+
+  override activeSubSolver: SingleOverlapSolver | null = null
+  private recentlyFailed = new Set<string>()
+  private detourCounts = new Map<string, number>()
+
+  private currentOverlap: {
+    trace: SolvedTracePath
+    label: NetLabelPlacement
+  } | null = null
+
+  constructor(params: NetLabelTraceCollisionSolverParams) {
+    super()
+    this.inputProblem = params.inputProblem
+    this.traces = params.traces
+    this.netLabelPlacements = params.netLabelPlacements
+    this.outputTraces = [...params.traces]
+    this.outputNetLabelPlacements = [...params.netLabelPlacements]
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof NetLabelTraceCollisionSolver
+  >[0] {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements,
+    }
+  }
+
+  override _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath
+        if (solvedPath) {
+          const idx = this.outputTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
+          )
+          if (idx !== -1) {
+            this.outputTraces[idx] = {
+              ...this.outputTraces[idx],
+              tracePath: solvedPath,
+            }
+          }
+        }
+        this.activeSubSolver = null
+        this.currentOverlap = null
+      } else if (this.activeSubSolver.failed) {
+        const key = this.getOverlapKey(
+          this.activeSubSolver.initialTrace,
+          this.activeSubSolver.label,
+        )
+        this.recentlyFailed.add(key)
+        this.activeSubSolver = null
+        this.currentOverlap = null
+      }
+      return
+    }
+
+    const overlaps = detectInnerTraceLabelOverlaps(
+      this.outputTraces,
+      this.outputNetLabelPlacements,
+    )
+
+    const actionable = overlaps.filter((o) => {
+      const key = this.getOverlapKey(o.trace, o.label)
+      return !this.recentlyFailed.has(key)
+    })
+
+    if (actionable.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const next = actionable[0]
+
+    const traceToFix = this.outputTraces.find(
+      (t) => t.mspPairId === next.trace.mspPairId,
+    )!
+
+    this.currentOverlap = next
+
+    // Merge all touching/overlapping labels into one obstacle so that fixing
+    // one collision doesn't immediately create another with an adjacent label.
+    const mergedLabel = buildMergedObstacleLabel(
+      next.label,
+      this.outputNetLabelPlacements.filter(
+        (l) => l.globalConnNetId !== traceToFix.globalConnNetId,
+      ),
+    )
+
+    const mergeKey = `${next.trace.mspPairId}::merged::${mergedLabel.center.x},${mergedLabel.center.y},${mergedLabel.width},${mergedLabel.height}`
+    const detourCount = this.detourCounts.get(mergeKey) ?? 0
+    if (detourCount >= MAX_DETOUR_ATTEMPTS) {
+      this.recentlyFailed.add(this.getOverlapKey(next.trace, next.label))
+      this.currentOverlap = null
+      return
+    }
+    this.detourCounts.set(mergeKey, detourCount + 1)
+
+    this.activeSubSolver = new SingleOverlapSolver({
+      trace: traceToFix,
+      label: mergedLabel,
+      problem: this.inputProblem,
+      paddingBuffer: PADDING_BUFFER,
+      detourCount,
+    })
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements,
+    }
+  }
+
+  private getOverlapKey(trace: SolvedTracePath, label: NetLabelPlacement) {
+    return `${trace.mspPairId}::${label.globalConnNetId}`
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) return this.activeSubSolver.visualize()
+
+    const graphics = visualizeInputProblem(this.inputProblem)
+    if (!graphics.lines) graphics.lines = []
+    if (!graphics.rects) graphics.rects = []
+    if (!graphics.points) graphics.points = []
+
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      } as any)
+    }
+
+    for (const label of this.outputNetLabelPlacements) {
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}`,
+      } as any)
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+      } as any)
+    }
+
+    if (this.currentOverlap) {
+      graphics.lines.push({
+        points: this.currentOverlap.trace.tracePath,
+        strokeColor: "red",
+      } as any)
+      graphics.rects.push({
+        center: this.currentOverlap.label.center,
+        width: this.currentOverlap.label.width,
+        height: this.currentOverlap.label.height,
+        fill: "rgba(255,0,0,0.3)",
+        strokeColor: "red",
+      } as any)
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -25,6 +25,7 @@ import { Example28Solver } from "../Example28Solver/Example28Solver"
 import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
 import { VccNetLabelCornerPlacementSolver } from "../VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver"
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
+import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -78,6 +79,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   availableNetOrientationSolver?: AvailableNetOrientationSolver
   vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
+  netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -285,6 +287,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "netLabelTraceCollisionSolver",
+      NetLabelTraceCollisionSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.availableNetOrientationSolver!.traces,
+          netLabelPlacements:
+            instance.traceAnchoredNetLabelOverlapSolver!
+              .outputNetLabelPlacements,
+        },
+      ],
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.55",
+  "version": "0.0.56",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/examples/example33.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example33.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/tests/assets/example33.json

@@ -0,0 +1,132 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": -1.4,
+        "y": -6.6
+      },
+      "width": 1.1,
+      "height": 0.388910699999999,
+      "pins": [
+        {
+          "pinId": "R7.1",
+          "x": -1.95,
+          "y": -6.6
+        },
+        {
+          "pinId": "R7.2",
+          "x": -0.8499999999999999,
+          "y": -6.6
+        }
+      ],
+      "sectionId": "qspi"
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": {
+        "x": 0,
+        "y": -8.4
+      },
+      "width": 3.045,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "U5.1",
+          "x": -1.5225,
+          "y": -8.1
+        },
+        {
+          "pinId": "U5.2",
+          "x": -1.5225,
+          "y": -8.3
+        },
+        {
+          "pinId": "U5.3",
+          "x": -1.5225,
+          "y": -8.5
+        },
+        {
+          "pinId": "U5.4",
+          "x": -1.5225,
+          "y": -8.700000000000001
+        },
+        {
+          "pinId": "U5.5",
+          "x": 1.5225,
+          "y": -8.1
+        },
+        {
+          "pinId": "U5.6",
+          "x": 1.5225,
+          "y": -8.3
+        },
+        {
+          "pinId": "U5.7",
+          "x": 1.5225,
+          "y": -8.700000000000001
+        },
+        {
+          "pinId": "U5.8",
+          "x": 1.5225,
+          "y": -8.5
+        }
+      ],
+      "sectionId": "qspi"
+    }
+  ],
+  "directConnections": [],
+  "netConnections": [
+    {
+      "netId": "V3V3",
+      "pinIds": ["R7.1", "U5.8"],
+      "netLabelWidth": 0.4
+    },
+    {
+      "netId": "QSPI_CS",
+      "pinIds": ["R7.2", "U5.4"],
+      "netLabelWidth": 0.7
+    },
+    {
+      "netId": "QSPI_SCK",
+      "pinIds": ["U5.1"],
+      "netLabelWidth": 0.8
+    },
+    {
+      "netId": "QSPI_DATA0",
+      "pinIds": ["U5.2"],
+      "netLabelWidth": 1
+    },
+    {
+      "netId": "QSPI_DATA1",
+      "pinIds": ["U5.3"],
+      "netLabelWidth": 1
+    },
+    {
+      "netId": "QSPI_DATA2",
+      "pinIds": ["U5.5"],
+      "netLabelWidth": 1
+    },
+    {
+      "netId": "QSPI_DATA3",
+      "pinIds": ["U5.6"],
+      "netLabelWidth": 1
+    },
+    {
+      "netId": "GND",
+      "pinIds": ["U5.7"],
+      "netLabelWidth": 0.3
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "V3V3": ["y+"],
+    "QSPI_CS": ["x-", "x+"],
+    "QSPI_SCK": ["x-", "x+"],
+    "QSPI_DATA0": ["x-", "x+"],
+    "QSPI_DATA1": ["x-", "x+"],
+    "QSPI_DATA2": ["x-", "x+"],
+    "QSPI_DATA3": ["x-", "x+"],
+    "GND": ["y-"]
+  },
+  "maxMspPairDistance": 2.4
+}

package/tests/examples/__snapshots__/example33.snap.svg

@@ -0,0 +1,181 @@
+<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="white" />
+  <g>
+    <circle data-type="point" data-label="R7.1
+x-" data-x="-1.95" data-y="-6.6" cx="102.39751311443555" cy="200.26423159121816" r="3" fill="hsl(232, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="R7.2
+x+" data-x="-0.8499999999999999" data-y="-6.6" cx="222.07888090149598" cy="200.26423159121816" r="3" fill="hsl(233, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.1
+x-" data-x="-1.5225" data-y="-8.1" cx="148.91004468622495" cy="363.4660967553915" r="3" fill="hsl(203, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.2
+x-" data-x="-1.5225" data-y="-8.3" cx="148.91004468622495" cy="385.22634544394805" r="3" fill="hsl(204, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.3
+x-" data-x="-1.5225" data-y="-8.5" cx="148.91004468622495" cy="406.98659413250437" r="3" fill="hsl(205, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.4
+x-" data-x="-1.5225" data-y="-8.700000000000001" cx="148.91004468622495" cy="428.7468428210609" r="3" fill="hsl(206, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.5
+x+" data-x="1.5225" data-y="-8.1" cx="480.2098309694967" cy="363.4660967553915" r="3" fill="hsl(207, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.6
+x+" data-x="1.5225" data-y="-8.3" cx="480.2098309694967" cy="385.22634544394805" r="3" fill="hsl(208, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.7
+x+" data-x="1.5225" data-y="-8.700000000000001" cx="480.2098309694967" cy="428.7468428210609" r="3" fill="hsl(209, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="U5.8
+x+" data-x="1.5225" data-y="-8.5" cx="480.2098309694967" cy="406.98659413250437" r="3" fill="hsl(210, 100%, 50%, 0.8)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-2.15" data-y="-6.6" cx="80.63726442587912" cy="200.26423159121816" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-0.8499999999999999" data-y="-6.6" cx="222.07888090149598" cy="200.26423159121816" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-1.5225" data-y="-8.700000000000001" cx="148.91004468622495" cy="428.7468428210609" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-1.5225" data-y="-8.1" cx="148.91004468622495" cy="363.4660967553915" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-1.5225" data-y="-8.3" cx="148.91004468622495" cy="385.22634544394805" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="-1.5225" data-y="-8.5" cx="148.91004468622495" cy="406.98659413250437" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="1.5225" data-y="-8.1" cx="480.2098309694967" cy="363.4660967553915" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="1.5225" data-y="-8.3" cx="480.2098309694967" cy="385.22634544394805" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <circle data-type="point" data-label="" data-x="1.6235" data-y="-8.901" cx="491.19875655721773" cy="450.61589275306005" r="3" fill="hsl(40, 100%, 50%, 0.9)" />
+  </g>
+  <g>
+    <polyline data-points="-1.95,-6.6 1.5225,-8.5" data-type="line" data-label="" points="102.39751311443555,200.26423159121816 480.2098309694967,406.98659413250437" fill="none" stroke="hsl(154, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="-0.8499999999999999,-6.6 -1.5225,-8.700000000000001" data-type="line" data-label="" points="222.07888090149598,200.26423159121816 148.91004468622495,428.7468428210609" fill="none" stroke="hsl(172, 100%, 50%, 0.8)" stroke-width="1" stroke-dasharray="4 2" />
+  </g>
+  <g>
+    <polyline data-points="-1.95,-6.6 -2.15,-6.6 -2.15,-7.55 1.7225000000000004,-7.55 1.7225000000000004,-7.8999999999999995 2.6235,-7.8999999999999995 2.6235,-8.499999999999998 1.5225000000000002,-8.5" data-type="line" data-label="" points="102.39751311443555,200.26423159121816 80.63726442587912,200.26423159121816 80.63726442587912,303.62541286186126 501.97007965805324,303.62541286186126 501.97007965805324,341.70584806683496 600,341.70584806683496 600,406.98659413250414 480.20983096949675,406.98659413250437" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <polyline data-points="1.5225,-8.700000000000001 1.6235,-8.700000000000001 1.6235,-8.901" data-type="line" data-label="" points="480.2098309694967,428.7468428210609 491.19875655721773,428.7468428210609 491.19875655721773,450.61589275306005" fill="none" stroke="purple" stroke-width="1" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_0" data-x="-1.4" data-y="-6.6" x="102.39751311443555" y="179.10724771711682" width="119.68136778706042" height="42.313967748202685" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="schematic_component_1" data-x="0" data-y="-8.4" x="148.91004468622495" y="341.7058480668351" width="331.2997862832717" height="108.80124344278227" fill="hsl(24, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: V3V3
+globalConnNetId: connectivity_net0" data-x="-2.15" data-y="-6.3999999999999995" x="69.75714008160091" y="156.7437342141053" width="21.76024868855646" height="43.52049737711286" fill="#ef444466" stroke="#ef4444" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: QSPI_CS
+globalConnNetId: connectivity_net1" data-x="-0.4989999999999999" data-y="-6.6" x="222.18768214493878" y="189.38410724693995" width="76.1608704099475" height="21.76024868855643" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: QSPI_CS
+globalConnNetId: connectivity_net1" data-x="-1.8735" data-y="-8.700000000000001" x="72.64037303283462" y="417.8667184767828" width="76.16087040994756" height="21.760248688556317" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: QSPI_SCK
+globalConnNetId: connectivity_net2" data-x="-1.9234999999999998" data-y="-8.1" x="61.76024868855643" y="352.5859724111133" width="87.04099475422575" height="21.760248688556317" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: QSPI_DATA0
+globalConnNetId: connectivity_net3" data-x="-2.0235" data-y="-8.3" x="40" y="374.34622109966983" width="108.80124344278218" height="21.760248688556317" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: QSPI_DATA1
+globalConnNetId: connectivity_net4" data-x="-2.0235" data-y="-8.5" x="40" y="396.10646978822615" width="108.80124344278218" height="21.76024868855643" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: QSPI_DATA2
+globalConnNetId: connectivity_net5" data-x="2.0235" data-y="-8.1" x="480.3186322129395" y="352.5859724111133" width="108.80124344278215" height="21.760248688556317" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: QSPI_DATA3
+globalConnNetId: connectivity_net6" data-x="2.0235" data-y="-8.3" x="480.3186322129395" y="374.34622109966983" width="108.80124344278215" height="21.760248688556317" fill="hsl(40, 100%, 50%, 0.35)" stroke="black" stroke-width="0.009191071428571429" />
+  </g>
+  <g>
+    <rect data-type="rect" data-label="netId: GND
+globalConnNetId: connectivity_net7" data-x="1.6235" data-y="-9.051" x="480.3186322129395" y="450.61589275306005" width="21.76024868855643" height="32.64037303283476" fill="#00000066" stroke="#000000" stroke-width="0.009191071428571429" />
+  </g>
+  <g id="crosshair" style="display: none">
+    <line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5" />
+    <line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5" /><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text>
+  </g>
+  <script>
+    <![CDATA[
+    document.currentScript.parentElement.addEventListener('mousemove', (e) => {
+      const svg = e.currentTarget;
+      const rect = svg.getBoundingClientRect();
+      const x = e.clientX - rect.left;
+      const y = e.clientY - rect.top;
+      const crosshair = svg.getElementById('crosshair');
+      const h = svg.getElementById('crosshair-h');
+      const v = svg.getElementById('crosshair-v');
+      const coords = svg.getElementById('coordinates');
+
+      crosshair.style.display = 'block';
+      h.setAttribute('x1', '0');
+      h.setAttribute('x2', '640');
+      h.setAttribute('y1', y);
+      h.setAttribute('y2', y);
+      v.setAttribute('x1', x);
+      v.setAttribute('x2', x);
+      v.setAttribute('y1', '0');
+      v.setAttribute('y2', '640');
+
+      // Calculate real coordinates using inverse transformation
+      const matrix = {
+        "a": 108.8012434427822,
+        "c": 0,
+        "e": 314.55993782786084,
+        "b": 0,
+        "d": -108.8012434427822,
+        "f": -517.8239751311443
+      };
+      // Manually invert and apply the affine transform
+      // Since we only use translate and scale, we can directly compute:
+      // x' = (x - tx) / sx
+      // y' = (y - ty) / sy
+      const sx = matrix.a;
+      const sy = matrix.d;
+      const tx = matrix.e;
+      const ty = matrix.f;
+      const realPoint = {
+        x: (x - tx) / sx,
+        y: (y - ty) / sy // Flip y back since we used negative scale
+      }
+
+      coords.textContent = `(${realPoint.x.toFixed(2)}, ${realPoint.y.toFixed(2)})`;
+      coords.setAttribute('x', (x + 5).toString());
+      coords.setAttribute('y', (y - 5).toString());
+    });
+    document.currentScript.parentElement.addEventListener('mouseleave', () => {
+      document.currentScript.parentElement.getElementById('crosshair').style.display = 'none';
+    });
+    ]]>
+  </script>
+</svg>

package/tests/examples/example33.test.ts

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import inputProblem from "../assets/example33.json"
+import "tests/fixtures/matcher"
+
+test("example33", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})