@tscircuit/schematic-trace-solver 0.0.150 → 0.0.151

package/README.md

@@ -48,10 +48,12 @@ decides which connections deserve one; the solver only honors the request when
 the connection actually got routed, since there is nothing to run parallel to
 otherwise.
 
-The `InlineNetLabelSolver` runs last in the pipeline and exposes
-`inlineNetLabelPlacements`. A net that receives an inline label has its anchored
-`NetLabelPlacement` removed from `getOutput().netLabelPlacements`, so a net is
-never labeled twice.
+The `InlineNetLabelSolver` exposes `inlineNetLabelPlacements`. A net that
+receives an inline label has its anchored `NetLabelPlacement` removed from
+`getOutput().netLabelPlacements`, so a net is never labeled twice.
+`NetLabelToTraceSolver` then replaces pairs of port-only fallback labels with
+real traces whenever the router finds a clear path. Its `getOutput()` is the
+pipeline's final output.
 
 ```tsx
 directConnections: [

package/dist/index.d.ts

@@ -1266,6 +1266,12 @@ interface InlineNetLabelSolverInput {
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
 }
+interface InlineNetLabelOutput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    inlineNetLabelPlacements: InlineNetLabelPlacement[];
+}
 type InlineEligibleConnection = InputDirectConnection | InputNetConnection;
 /**
  * Places "inline net labels" - net names drawn alongside the trace they belong
@@ -1322,12 +1328,39 @@ declare class InlineNetLabelSolver extends BaseSolver {
     };
     visualize(): GraphicsObject;
 }
+declare const visualizeInlineNetLabelOutput: ({ inputProblem, traces, netLabelPlacements, inlineNetLabelPlacements, }: InlineNetLabelOutput) => GraphicsObject;
 /**
  * Mirrors the net label text width used by @tscircuit/core so a label that core
  * did not measure for us still reserves a sane amount of space.
  */
 declare const estimateInlineNetLabelWidth: (text: string, fontSize?: number) => number;
 
+declare class NetLabelToTraceSolver extends BaseSolver {
+    private input;
+    inputProblem: InputProblem;
+    outputTraces: SolvedTracePath[];
+    outputNetLabelPlacements: NetLabelPlacement[];
+    private chipMap;
+    private pinMap;
+    private queuedCandidates;
+    private currentCandidate;
+    activeSubSolver: SchematicTraceSingleLineSolver2 | null;
+    constructor(input: InlineNetLabelOutput);
+    getConstructorParams(): [InlineNetLabelOutput];
+    private isEligiblePortOnlyDirectConnectionLabel;
+    private buildCandidatePairs;
+    private isSupersededConnectorTrace;
+    private routeIntersectsRemainingLabels;
+    private tryAcceptCurrentRoute;
+    _step(): void;
+    getOutput(): {
+        traces: SolvedTracePath[];
+        netLabelPlacements: NetLabelPlacement[];
+        inlineNetLabelPlacements: InlineNetLabelPlacement[];
+    };
+    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.
@@ -1368,13 +1401,14 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     finalTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver;
     sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver;
     inlineNetLabelSolver?: InlineNetLabelSolver;
+    netLabelToTraceSolver?: NetLabelToTraceSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
     hideRatsNet: boolean;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceElbowTransitionSimplificationSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver> | PipelineStep<typeof SameNetJunctionAlignmentSolver> | PipelineStep<typeof InlineNetLabelSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceElbowTransitionSimplificationSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver> | PipelineStep<typeof SameNetJunctionAlignmentSolver> | PipelineStep<typeof InlineNetLabelSolver> | PipelineStep<typeof NetLabelToTraceSolver>)[];
     constructor(inputProblem: InputProblem, opts?: Options);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>;
     currentPipelineStepIndex: number;
@@ -1390,4 +1424,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, DEFAULT_INLINE_NET_LABEL_HEIGHT, INLINE_NET_LABEL_MAX_SPAN_JOG, INLINE_NET_LABEL_STUB_TRACE_CLEARANCE, INLINE_NET_LABEL_TRACE_MARGIN, type InlineNetLabelPlacement, InlineNetLabelSolver, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type NetLabelPlacement, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes, estimateInlineNetLabelWidth };
+export { type ChipId, DEFAULT_INLINE_NET_LABEL_HEIGHT, INLINE_NET_LABEL_MAX_SPAN_JOG, INLINE_NET_LABEL_STUB_TRACE_CLEARANCE, INLINE_NET_LABEL_TRACE_MARGIN, type InlineNetLabelOutput, type InlineNetLabelPlacement, InlineNetLabelSolver, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type NetLabelPlacement, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes, estimateInlineNetLabelWidth, visualizeInlineNetLabelOutput };

package/dist/index.js

@@ -13606,77 +13606,113 @@ var InlineNetLabelSolver = class extends BaseSolver {
     return this.buildPostProcessedOutput();
   }
   visualize() {
-    const graphics = visualizeInputProblem(this.inputProblem);
-    graphics.lines ??= [];
-    graphics.rects ??= [];
-    graphics.points ??= [];
-    graphics.texts ??= [];
-    const output = this.getOutput();
-    for (const trace of output.traces) {
+    return visualizeInlineNetLabelOutput({
+      inputProblem: this.inputProblem,
+      ...this.getOutput()
+    });
+  }
+};
+var visualizeInlineNetLabelOutput = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  inlineNetLabelPlacements
+}) => {
+  const graphics = visualizeInputProblem(inputProblem);
+  graphics.lines ??= [];
+  graphics.rects ??= [];
+  graphics.points ??= [];
+  graphics.texts ??= [];
+  for (const trace of traces) {
+    graphics.lines.push({
+      points: trace.tracePath,
+      strokeColor: "purple"
+    });
+  }
+  for (const label of netLabelPlacements) {
+    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),
+      label: `anchorPoint
+orientation: ${label.orientation}`
+    });
+  }
+  for (const inlineLabel of inlineNetLabelPlacements) {
+    if (inlineLabel.stubTracePath) {
       graphics.lines.push({
-        points: trace.tracePath,
+        points: inlineLabel.stubTracePath,
         strokeColor: "purple"
       });
     }
-    const { netLabelPlacements } = this.getOutput();
-    for (const label of netLabelPlacements) {
-      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),
-        label: `anchorPoint
-orientation: ${label.orientation}`
-      });
+    const isHorizontal4 = inlineLabel.axis === "x";
+    let renderedWidth = inlineLabel.width;
+    let renderedHeight = inlineLabel.height;
+    if (!isHorizontal4) {
+      renderedWidth = inlineLabel.height;
+      renderedHeight = inlineLabel.width;
     }
-    for (const inlineLabel of this.inlineNetLabelPlacements) {
-      if (inlineLabel.stubTracePath) {
-        graphics.lines.push({
-          points: inlineLabel.stubTracePath,
-          strokeColor: "purple"
-        });
+    graphics.rects.push({
+      center: inlineLabel.center,
+      width: renderedWidth,
+      height: renderedHeight,
+      fill: getColorFromString(inlineLabel.globalConnNetId, 0.35),
+      strokeColor: "green",
+      label: [
+        `INLINE netId: ${inlineLabel.netId}`,
+        `axis: ${inlineLabel.axis}`,
+        `side: ${inlineLabel.side}`
+      ].join("\n")
+    });
+    let textX = inlineLabel.center.x;
+    let textY = inlineLabel.center.y;
+    let anchorSide = "center";
+    let rotation;
+    if (inlineLabel.stubTracePath) {
+      const stubStart = inlineLabel.stubTracePath[0];
+      const stubEnd = inlineLabel.stubTracePath[1];
+      let labelOffset = inlineLabel.width / 2;
+      if (stubEnd[inlineLabel.axis] > stubStart[inlineLabel.axis]) {
+        labelOffset = -inlineLabel.width / 2;
+        anchorSide = "center_left";
+      } else {
+        anchorSide = "center_right";
+      }
+      if (inlineLabel.axis === "x") {
+        textX += labelOffset;
+      } else {
+        textY += labelOffset;
       }
-      const isHorizontal4 = inlineLabel.axis === "x";
-      graphics.rects.push({
-        center: inlineLabel.center,
-        width: isHorizontal4 ? inlineLabel.width : inlineLabel.height,
-        height: isHorizontal4 ? inlineLabel.height : inlineLabel.width,
-        fill: getColorFromString(inlineLabel.globalConnNetId, 0.35),
-        strokeColor: "green",
-        label: [
-          `INLINE netId: ${inlineLabel.netId}`,
-          `axis: ${inlineLabel.axis}`,
-          `side: ${inlineLabel.side}`
-        ].join("\n")
-      });
-      graphics.texts.push({
-        x: inlineLabel.stubTracePath && inlineLabel.axis === "x" ? inlineLabel.center.x + (inlineLabel.stubTracePath[1].x > inlineLabel.stubTracePath[0].x ? -inlineLabel.width / 2 : inlineLabel.width / 2) : inlineLabel.center.x,
-        y: inlineLabel.stubTracePath && inlineLabel.axis === "y" ? inlineLabel.center.y + (inlineLabel.stubTracePath[1].y > inlineLabel.stubTracePath[0].y ? -inlineLabel.width / 2 : inlineLabel.width / 2) : inlineLabel.center.y,
-        text: inlineLabel.netLabelText ?? inlineLabel.netId ?? "",
-        color: "green",
-        fontSize: inlineLabel.height,
-        anchorSide: inlineLabel.stubTracePath ? inlineLabel.stubTracePath[1][inlineLabel.axis] > inlineLabel.stubTracePath[0][inlineLabel.axis] ? "center_left" : "center_right" : "center",
-        // Vertical labels read bottom-to-top, alongside the wire they name.
-        rotation: inlineLabel.axis === "y" ? 90 : void 0
-      });
-      graphics.points.push({
-        x: inlineLabel.anchorPoint.x,
-        y: inlineLabel.anchorPoint.y,
-        color: "green",
-        label: `inline anchor
-${inlineLabel.netLabelText ?? inlineLabel.netId}`
-      });
     }
-    return graphics;
+    if (inlineLabel.axis === "y") rotation = 90;
+    graphics.texts.push({
+      x: textX,
+      y: textY,
+      text: inlineLabel.netLabelText ?? inlineLabel.netId ?? "",
+      color: "green",
+      fontSize: inlineLabel.height,
+      anchorSide,
+      // Vertical labels read bottom-to-top, alongside the wire they name.
+      rotation
+    });
+    graphics.points.push({
+      x: inlineLabel.anchorPoint.x,
+      y: inlineLabel.anchorPoint.y,
+      color: "green",
+      label: `inline anchor
+${inlineLabel.netLabelText ?? inlineLabel.netId}`
+    });
   }
+  return graphics;
 };
 var estimateInlineNetLabelWidth = (text, fontSize = DEFAULT_INLINE_NET_LABEL_HEIGHT) => {
   const fontScale = fontSize / 0.18;
@@ -13762,6 +13798,250 @@ var getCollisionLimitedTerminalStubEnd = ({
   return isHorizontal4 ? { x: start.x + direction * availableLength, y: start.y } : { x: start.x, y: start.y + direction * availableLength };
 };
 
+// lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
+import {
+  doesSegmentIntersectRect,
+  getBoundFromCenteredRect
+} from "@tscircuit/math-utils";
+
+// lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps.ts
+var getTraceRecoveryConnectivityMaps = (inputProblem) => {
+  const chipMap = {};
+  const pinMap = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    chipMap[chip.chipId] = chip;
+    for (const pin of chip.pins) {
+      pinMap.set(pin.pinId, {
+        ...pin,
+        chipId: chip.chipId,
+        _facingDirection: pin._facingDirection ?? getPinDirection(pin, chip)
+      });
+    }
+  }
+  return { chipMap, pinMap };
+};
+
+// lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
+var AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-";
+var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
+var getCanonicalPairKey = (firstPinId, secondPinId) => [firstPinId, secondPinId].sort().join("--");
+var pathIntersectsRenderedLabel = (path, label) => {
+  let width = label.width;
+  let height = label.height;
+  if ("axis" in label && label.axis === "y") {
+    width = label.height;
+    height = label.width;
+  }
+  const bounds = getBoundFromCenteredRect({
+    center: label.center,
+    width,
+    height
+  });
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    if (doesSegmentIntersectRect(path[pathIndex], path[pathIndex + 1], bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
+var getPerpendicularOffset = (firstPin, secondPin) => {
+  const xDistance = Math.abs(firstPin.x - secondPin.x);
+  const yDistance = Math.abs(firstPin.y - secondPin.y);
+  if (xDistance >= yDistance) return yDistance;
+  return xDistance;
+};
+var NetLabelToTraceSolver = class extends BaseSolver {
+  constructor(input) {
+    super();
+    this.input = input;
+    this.inputProblem = input.inputProblem;
+    this.outputTraces = [...input.traces];
+    this.outputNetLabelPlacements = [...input.netLabelPlacements];
+    const { chipMap, pinMap } = getTraceRecoveryConnectivityMaps(
+      this.inputProblem
+    );
+    this.chipMap = chipMap;
+    this.pinMap = pinMap;
+    this.queuedCandidates = this.buildCandidatePairs();
+    this.stats.candidateCount = this.queuedCandidates.length;
+    this.stats.recoveredTraceCount = 0;
+  }
+  input;
+  inputProblem;
+  outputTraces;
+  outputNetLabelPlacements;
+  chipMap;
+  pinMap;
+  queuedCandidates;
+  currentCandidate = null;
+  getConstructorParams() {
+    return [this.input];
+  }
+  isEligiblePortOnlyDirectConnectionLabel(label, groundGlobalConnNetId) {
+    if (label.pinIds.length !== 1 || label.mspConnectionPairIds.length !== 0 || !label.netId || label.netId === "GND" || label.globalConnNetId === groundGlobalConnNetId) {
+      return false;
+    }
+    const pinId = label.pinIds[0];
+    return this.inputProblem.directConnections.some(
+      (connection) => connection.netId === label.netId && connection.pinIds.includes(pinId)
+    );
+  }
+  buildCandidatePairs() {
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem
+    );
+    const groundGlobalConnNetId = netConnMap.getNetConnectedToId("GND") ?? void 0;
+    const labelsByGlobalNet = /* @__PURE__ */ new Map();
+    for (const label of this.input.netLabelPlacements) {
+      if (!this.isEligiblePortOnlyDirectConnectionLabel(
+        label,
+        groundGlobalConnNetId
+      )) {
+        continue;
+      }
+      const labels = labelsByGlobalNet.get(label.globalConnNetId) ?? [];
+      labels.push(label);
+      labelsByGlobalNet.set(label.globalConnNetId, labels);
+    }
+    const candidates = [];
+    for (const labels of labelsByGlobalNet.values()) {
+      for (let firstIndex = 0; firstIndex < labels.length; firstIndex++) {
+        for (let secondIndex = firstIndex + 1; secondIndex < labels.length; secondIndex++) {
+          const firstLabel = labels[firstIndex];
+          const secondLabel = labels[secondIndex];
+          const firstPin = this.pinMap.get(firstLabel.pinIds[0]);
+          const secondPin = this.pinMap.get(secondLabel.pinIds[0]);
+          if (!firstPin || !secondPin) continue;
+          if (arePinsInDifferentSchematicSections(
+            this.inputProblem,
+            firstPin,
+            secondPin
+          )) {
+            continue;
+          }
+          if (doesPairCrossRestrictedCenterLines({
+            inputProblem: this.inputProblem,
+            chipMap: this.chipMap,
+            pinIdMap: this.pinMap,
+            p1: firstPin,
+            p2: secondPin
+          })) {
+            continue;
+          }
+          candidates.push({
+            firstLabel,
+            secondLabel,
+            pins: [firstPin, secondPin],
+            perpendicularOffset: getPerpendicularOffset(firstPin, secondPin),
+            routeDistance: Math.abs(firstPin.x - secondPin.x) + Math.abs(firstPin.y - secondPin.y),
+            key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId)
+          });
+        }
+      }
+    }
+    candidates.sort(
+      (first, second) => first.perpendicularOffset - second.perpendicularOffset || first.routeDistance - second.routeDistance || first.key.localeCompare(second.key)
+    );
+    return candidates;
+  }
+  isSupersededConnectorTrace(trace, candidate) {
+    if (!trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_PREFIX)) {
+      return false;
+    }
+    if (trace.pinIds.length !== 1) return false;
+    return candidate.pins.some((pin) => pin.pinId === trace.pinIds[0]);
+  }
+  routeIntersectsRemainingLabels(tracePath, candidate) {
+    for (const label of this.outputNetLabelPlacements) {
+      if (label === candidate.firstLabel || label === candidate.secondLabel) {
+        continue;
+      }
+      if (pathIntersectsRenderedLabel(tracePath, label)) return true;
+    }
+    return this.input.inlineNetLabelPlacements.some(
+      (label) => pathIntersectsRenderedLabel(tracePath, label)
+    );
+  }
+  tryAcceptCurrentRoute() {
+    const candidate = this.currentCandidate;
+    const tracePath = this.activeSubSolver?.solvedTracePath;
+    if (!candidate || !tracePath) return;
+    const retainedTraces = this.outputTraces.filter(
+      (trace) => !this.isSupersededConnectorTrace(trace, candidate)
+    );
+    if (doesTraceOverlapWithExistingTraces(tracePath, retainedTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
+      return;
+    }
+    const [firstPin, secondPin] = candidate.pins;
+    const mspPairId = `${RECOVERED_TRACE_PREFIX}${candidate.key}`;
+    const recoveredTrace = {
+      mspPairId,
+      dcConnNetId: candidate.firstLabel.globalConnNetId,
+      globalConnNetId: candidate.firstLabel.globalConnNetId,
+      pins: [firstPin, secondPin],
+      tracePath,
+      mspConnectionPairIds: [mspPairId],
+      pinIds: [firstPin.pinId, secondPin.pinId]
+    };
+    this.outputTraces = [...retainedTraces, recoveredTrace];
+    this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
+      (label) => label !== candidate.firstLabel && label !== candidate.secondLabel
+    );
+    this.stats.recoveredTraceCount++;
+  }
+  _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        this.tryAcceptCurrentRoute();
+        this.activeSubSolver = null;
+        this.currentCandidate = null;
+      } else if (this.activeSubSolver.failed) {
+        this.activeSubSolver = null;
+        this.currentCandidate = null;
+      }
+      return;
+    }
+    let candidate = this.queuedCandidates.shift();
+    while (candidate && (!this.outputNetLabelPlacements.includes(candidate.firstLabel) || !this.outputNetLabelPlacements.includes(candidate.secondLabel))) {
+      candidate = this.queuedCandidates.shift();
+    }
+    if (!candidate) {
+      this.solved = true;
+      return;
+    }
+    this.currentCandidate = candidate;
+    this.activeSubSolver = new SchematicTraceSingleLineSolver2({
+      inputProblem: this.inputProblem,
+      pins: candidate.pins,
+      chipMap: this.chipMap
+    });
+  }
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements,
+      inlineNetLabelPlacements: this.input.inlineNetLabelPlacements
+    };
+  }
+  visualize() {
+    if (this.activeSubSolver) return this.activeSubSolver.visualize();
+    const graphics = visualizeInlineNetLabelOutput({
+      inputProblem: this.inputProblem,
+      ...this.getOutput()
+    });
+    for (const trace of this.outputTraces) {
+      if (!trace.mspPairId.startsWith(RECOVERED_TRACE_PREFIX)) continue;
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "green",
+        label: `recovered from net labels: ${trace.pinIds.join(" -> ")}`
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -13800,6 +14080,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   finalTraceElbowTransitionSimplificationSolver;
   sameNetJunctionAlignmentSolver;
   inlineNetLabelSolver;
+  netLabelToTraceSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -14211,6 +14492,19 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           }
         ];
       }
+    ),
+    definePipelineStep(
+      "netLabelToTraceSolver",
+      NetLabelToTraceSolver,
+      (instance) => {
+        const inlineOutput = instance.inlineNetLabelSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            ...inlineOutput
+          }
+        ];
+      }
     )
   ];
   constructor(inputProblem, opts) {
@@ -14331,5 +14625,6 @@ export {
   InlineNetLabelSolver,
   SchematicTracePipelineSolver,
   SchematicTraceSingleLineSolver2,
-  estimateInlineNetLabelWidth
+  estimateInlineNetLabelWidth,
+  visualizeInlineNetLabelOutput
 };