@tscircuit/schematic-trace-solver 0.0.149 → 0.0.151

package/dist/index.js

@@ -2742,6 +2742,7 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
       dcConnNetId: void 0,
       netId: overlappingSameNetTraceGroup.netId,
+      netLabelText: overlappingSameNetTraceGroup.netLabelText,
       mspConnectionPairIds: [],
       pinIds: [pinId],
       orientation,
@@ -2773,6 +2774,7 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
     dcConnNetId: void 0,
     netId: overlappingSameNetTraceGroup.netId,
+    netLabelText: overlappingSameNetTraceGroup.netLabelText,
     mspConnectionPairIds: [],
     pinIds: [pinId],
     orientation: fallbackOrientation,
@@ -3059,6 +3061,7 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
               globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
               dcConnNetId: curr.dcConnNetId,
               netId: this.overlappingSameNetTraceGroup.netId,
+              netLabelText: this.overlappingSameNetTraceGroup.netLabelText,
               mspConnectionPairIds: [curr.mspPairId],
               pinIds: [curr.pins[0].pinId, curr.pins[1].pinId],
               orientation,
@@ -3078,6 +3081,7 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
         globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
         dcConnNetId: bestCandidate.dcConnNetId,
         netId: this.overlappingSameNetTraceGroup.netId,
+        netLabelText: this.overlappingSameNetTraceGroup.netLabelText,
         mspConnectionPairIds: [bestCandidate.mspPairId],
         pinIds: bestCandidate.pinIds,
         orientation: bestCandidate.orientation,
@@ -3133,16 +3137,25 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       }
     }
     const userNetIdByPinId = {};
+    const netLabelTextByPinId = {};
     for (const dc of this.inputProblem.directConnections) {
       if (dc.netId) {
         const [a, b] = dc.pinIds;
         userNetIdByPinId[a] = dc.netId;
         userNetIdByPinId[b] = dc.netId;
       }
+      const netLabelText = dc.netLabelText?.trim();
+      if (netLabelText) {
+        const [a, b] = dc.pinIds;
+        netLabelTextByPinId[a] = netLabelText;
+        netLabelTextByPinId[b] = netLabelText;
+      }
     }
     for (const nc of this.inputProblem.netConnections) {
       for (const pid of nc.pinIds) {
         userNetIdByPinId[pid] = nc.netId;
+        const netLabelText = nc.netLabelText?.trim();
+        if (netLabelText) netLabelTextByPinId[pid] = netLabelText;
       }
     }
     const groups = [];
@@ -3228,6 +3241,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
           const group = {
             globalConnNetId,
             netId: userNetId,
+            netLabelText: [...component].map((pinId) => netLabelTextByPinId[pinId]).find((text) => Boolean(text)),
             overlappingTraces: rep,
             mspConnectionPairIds
           };
@@ -3239,6 +3253,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
             groups.push({
               globalConnNetId,
               netId: userNetId,
+              netLabelText: netLabelTextByPinId[p],
               portOnlyPinId: p
             });
           }
@@ -13326,7 +13341,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
     );
     const inputPin = inputChip?.pins.find((pin) => pin.pinId === pinId);
     const height = connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
-    const width = connection.inlineNetLabelWidth ?? connection.netLabelWidth ?? estimateInlineNetLabelWidth(connection.netId, height);
+    const netLabelText = connection.netLabelText?.trim() || void 0;
+    const width = connection.inlineNetLabelWidth ?? connection.netLabelWidth ?? estimateInlineNetLabelWidth(netLabelText ?? connection.netId, height);
     const stubLength = Math.max(width + 0.2, 0.6);
     const start = inputPin ? { x: inputPin.x, y: inputPin.y } : anchoredPlacement.anchorPoint;
     const direction = inputPin && inputChip ? inputPin._facingDirection ?? getPinDirection(inputPin, inputChip) : anchoredPlacement.orientation;
@@ -13368,6 +13384,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     return {
       globalConnNetId: anchoredPlacement.globalConnNetId,
       netId: connection.netId,
+      netLabelText,
       pinIds: [pinId],
       stubTracePath: [start, end],
       axis,
@@ -13385,7 +13402,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
     const segments = getAxisAlignedSegments(trace.tracePath);
     if (segments.length === 0) return null;
     const height = connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
-    const width = connection.inlineNetLabelWidth ?? connection.netLabelWidth ?? estimateInlineNetLabelWidth(connection.netId, height);
+    const netLabelText = connection.netLabelText?.trim() || void 0;
+    const width = connection.inlineNetLabelWidth ?? connection.netLabelWidth ?? estimateInlineNetLabelWidth(netLabelText ?? connection.netId, height);
     const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN;
     const usableSegments = segments.filter((segment) => segment.length >= width).sort((a, b) => b.length - a.length);
     for (const segment of usableSegments) {
@@ -13414,6 +13432,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
           return {
             globalConnNetId: trace.globalConnNetId,
             netId: connection.netId,
+            netLabelText,
             mspPairId: trace.mspPairId,
             pinIds: [...connection.pinIds],
             axis: segment.axis,
@@ -13429,6 +13448,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     const spanPlacement = this.computeSpanPlacement({
       trace,
       connection,
+      netLabelText,
       width,
       height,
       offset
@@ -13445,6 +13465,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
   computeSpanPlacement({
     trace,
     connection,
+    netLabelText,
     width,
     height,
     offset
@@ -13504,6 +13525,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
         return {
           globalConnNetId: trace.globalConnNetId,
           netId: connection.netId,
+          netLabelText,
           mspPairId: trace.mspPairId,
           pinIds: [...connection.pinIds],
           axis,
@@ -13584,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.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.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;
@@ -13740,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 {
@@ -13778,6 +14080,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   finalTraceElbowTransitionSimplificationSolver;
   sameNetJunctionAlignmentSolver;
   inlineNetLabelSolver;
+  netLabelToTraceSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -14189,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) {
@@ -14309,5 +14625,6 @@ export {
   InlineNetLabelSolver,
   SchematicTracePipelineSolver,
   SchematicTraceSingleLineSolver2,
-  estimateInlineNetLabelWidth
+  estimateInlineNetLabelWidth,
+  visualizeInlineNetLabelOutput
 };