@tscircuit/schematic-trace-solver 0.0.46 → 0.0.47

package/dist/index.d.ts

@@ -435,6 +435,7 @@ declare class SingleOverlapSolver extends BaseSolver {
     problem: InputProblem;
     obstacles: ReturnType<typeof getObstacleRects>;
     label: NetLabelPlacement;
+    _tried: number;
     constructor(solverInput: SingleOverlapSolverInput);
     _step(): void;
     visualize(): GraphicsObject;
@@ -446,6 +447,7 @@ interface OverlapCollectionSolverInput {
     initialNetLabelPlacements: NetLabelPlacement[];
     mergedNetLabelPlacements: NetLabelPlacement[];
     mergedLabelNetIdMap: Record<string, Set<string>>;
+    detourCounts: Map<string, number>;
 }
 /**
  * This is an internal solver that manages the step-by-step process of avoiding
@@ -458,8 +460,8 @@ declare class OverlapAvoidanceStepSolver extends BaseSolver {
     mergedLabelNetIdMap: Record<string, Set<string>>;
     allTraces: SolvedTracePath[];
     modifiedTraces: SolvedTracePath[];
-    private detourCountByLabel;
     private readonly PADDING_BUFFER;
+    private detourCounts;
     activeSubSolver: SingleOverlapSolver | null;
     private overlapQueue;
     private recentlyFailed;
@@ -470,6 +472,7 @@ declare class OverlapAvoidanceStepSolver extends BaseSolver {
     getOutput(): {
         allTraces: SolvedTracePath[];
         modifiedTraces: SolvedTracePath[];
+        detourCounts: Map<string, number>;
     };
     visualize(): GraphicsObject;
 }
@@ -480,29 +483,28 @@ interface TraceLabelOverlapAvoidanceSolverInput {
     netLabelPlacements: NetLabelPlacement[];
 }
 /**
- * A pipeline solver responsible for resolving overlaps between schematic traces and net labels.
+ * Resolves overlaps between schematic traces and net labels using a two-phase,
+ * "fire-and-forget" dispatching strategy.
  *
- * 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.
+ * This solver operates in two distinct phases:
  *
- * 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.
+ * 1.  **Dispatch Phase**: Iterates through traces, identifying clean ones and dispatching
+ *     colliding ones to dedicated `OverlapAvoidanceStepSolver` instances.
  *
- * @param {TraceLabelOverlapAvoidanceSolverInput} solverInput - The input for the solver,
- *   containing the initial traces, label placements, and the input problem definition.
+ * 2.  **Execution Phase**: Steps through all dispatched sub-solvers until they complete.
+ *
+ * The final output combines clean traces with results from sub-solvers. A final
+ * `MergedNetLabelObstacleSolver` ensures pipeline compatibility.
  */
 declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     inputProblem: InputProblem;
-    traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
+    unprocessedTraces: SolvedTracePath[];
+    cleanTraces: SolvedTracePath[];
+    subSolvers: OverlapAvoidanceStepSolver[];
+    private phase;
+    detourCounts: Map<string, number>;
     labelMergingSolver?: MergedNetLabelObstacleSolver;
-    overlapAvoidanceSolver?: OverlapAvoidanceStepSolver;
-    pipelineStepIndex: number;
     constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput);
     _step(): void;
     getOutput(): {

package/dist/index.js

@@ -2649,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)
   ]);
 };
 
@@ -2759,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({
@@ -2791,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;
@@ -2798,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;
@@ -2821,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)) {
@@ -2866,13 +2904,38 @@ 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/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
@@ -2908,8 +2971,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
   mergedLabelNetIdMap;
   allTraces;
   modifiedTraces = [];
-  detourCountByLabel = {};
   PADDING_BUFFER = 0.1;
+  detourCounts = /* @__PURE__ */ new Map();
   activeSubSolver = null;
   overlapQueue = [];
   recentlyFailed = /* @__PURE__ */ new Set();
@@ -2922,6 +2985,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
     this.mergedNetLabelPlacements = solverInput.mergedNetLabelPlacements;
     this.mergedLabelNetIdMap = solverInput.mergedLabelNetIdMap;
     this.allTraces = [...solverInput.traces];
+    this.detourCounts = solverInput.detourCounts;
   }
   _step() {
     this.currentlyProcessingOverlap = null;
@@ -2973,7 +3037,6 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         (t) => t.mspPairId === nextOverlap.trace.mspPairId
       );
       const labelToAvoid = nextOverlap.label;
-      const traceStartPoint = traceToFix.tracePath[0];
       const originalNetIds = this.mergedLabelNetIdMap[labelToAvoid.globalConnNetId];
       const isSelfOverlap = originalNetIds?.has(traceToFix.globalConnNetId);
       if (isSelfOverlap) {
@@ -2993,9 +3056,11 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
           }
         }
         if (actualOverlapLabel) {
-          const labelId2 = actualOverlapLabel.globalConnNetId;
-          const detourCount2 = this.detourCountByLabel[labelId2] || 0;
-          this.detourCountByLabel[labelId2] = detourCount2 + 1;
+          const detourCount2 = this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0;
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            detourCount2 + 1
+          );
           this.activeSubSolver = new SingleOverlapSolver({
             trace: traceToFix,
             label: actualOverlapLabel,
@@ -3009,7 +3074,7 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         }
         return;
       }
-      if (originalNetIds && isPointInsideLabel({ point: traceStartPoint, label: labelToAvoid })) {
+      if (originalNetIds && doesTraceStartOrEndInLabel({ trace: traceToFix, label: labelToAvoid })) {
         const childLabels = this.initialNetLabelPlacements.filter(
           (l) => originalNetIds.has(l.globalConnNetId)
         );
@@ -3026,9 +3091,11 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
           }
         }
         if (actualOverlapLabel) {
-          const labelId2 = actualOverlapLabel.globalConnNetId;
-          const detourCount2 = this.detourCountByLabel[labelId2] || 0;
-          this.detourCountByLabel[labelId2] = detourCount2 + 1;
+          const detourCount2 = this.detourCounts.get(actualOverlapLabel.globalConnNetId) ?? 0;
+          this.detourCounts.set(
+            actualOverlapLabel.globalConnNetId,
+            detourCount2 + 1
+          );
           this.activeSubSolver = new SingleOverlapSolver({
             trace: traceToFix,
             label: actualOverlapLabel,
@@ -3042,9 +3109,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
         }
         return;
       }
-      const labelId = labelToAvoid.globalConnNetId;
-      const detourCount = this.detourCountByLabel[labelId] || 0;
-      this.detourCountByLabel[labelId] = detourCount + 1;
+      const detourCount = this.detourCounts.get(labelToAvoid.globalConnNetId) ?? 0;
+      this.detourCounts.set(labelToAvoid.globalConnNetId, detourCount + 1);
       this.activeSubSolver = new SingleOverlapSolver({
         trace: traceToFix,
         label: labelToAvoid,
@@ -3057,7 +3123,8 @@ var OverlapAvoidanceStepSolver = class extends BaseSolver {
   getOutput() {
     return {
       allTraces: this.allTraces,
-      modifiedTraces: this.modifiedTraces
+      modifiedTraces: this.modifiedTraces,
+      detourCounts: this.detourCounts
     };
   }
   visualize() {
@@ -3110,76 +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,
+          traces: [currentTargetTrace],
           initialNetLabelPlacements: this.netLabelPlacements,
-          // The original, unfiltered list
-          mergedNetLabelPlacements: this.labelMergingSolver.getOutput().netLabelPlacements,
-          mergedLabelNetIdMap: this.labelMergingSolver.getOutput().mergedLabelNetIdMap
+          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,