@tscircuit/schematic-trace-solver 0.0.141 → 0.0.143

package/dist/index.d.ts

@@ -115,6 +115,16 @@ interface InputNetConnection {
     pinIds: Array<PinId>;
     netLabelWidth?: number;
     netLabelHeight?: number;
+    /**
+     * When true, a named single-pin net may be drawn as a short outward trace
+     * stub with its net name placed inline. Multi-pin net connections retain the
+     * regular anchored-label behavior.
+     */
+    allowInlineNetLabel?: boolean;
+    /** Extent of the inline text along the generated trace stub. */
+    inlineNetLabelWidth?: number;
+    /** Height of the inline text perpendicular to the generated trace stub. */
+    inlineNetLabelHeight?: number;
 }
 interface InputProblem {
     chips: Array<InputChip>;
@@ -815,6 +825,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private findValidTraceAnchorCandidate;
     private findValidOutwardTraceAnchorCandidate;
     private getTraceAnchorCandidatePoints;
+    private sharesVerticalRailWithAny;
     private getAvailableOrientations;
     private findValidShiftedCandidate;
     /**
@@ -1186,8 +1197,13 @@ declare const INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4;
 interface InlineNetLabelPlacement {
     globalConnNetId: string;
     netId?: string;
-    mspPairId: string;
+    mspPairId?: string;
     pinIds: PinId[];
+    /**
+     * A generated single-ended trace stub. Present only for an eligible
+     * single-pin net connection; routed point-to-point traces omit it.
+     */
+    stubTracePath?: [Point, Point];
     /** Axis the text runs along: "x" reads left-to-right, "y" reads bottom-to-top */
     axis: "x" | "y";
     /** Midpoint of the trace segment the label is attached to */
@@ -1224,10 +1240,20 @@ declare class InlineNetLabelSolver extends BaseSolver {
     inlineNetLabelPlacements: InlineNetLabelPlacement[];
     /** Direct connections that opted in, still waiting to be processed */
     queuedDirectConnections: InputDirectConnection[];
+    /** Single-pin net connections that opted in, still waiting to be processed */
+    queuedPortOnlyNetConnections: InputNetConnection[];
     private tracesByPinPairKey;
+    private hasAlignedPortOnlyStubs;
     constructor(input: InlineNetLabelSolverInput);
     getConstructorParams(): [InlineNetLabelSolverInput];
     _step(): void;
+    /**
+     * Converts a conventional port-only anchored placement into an inline label
+     * on a generated outward stub. The stub follows the pin's true facing
+     * direction; an anchored label may finish in another direction after an
+     * elbow, which is not the direction a terminal stub should leave the pin.
+     */
+    private computePortOnlyInlinePlacement;
     private computeInlinePlacement;
     /**
      * Places the label over the whole route when the route is straight except
@@ -1246,6 +1272,7 @@ declare class InlineNetLabelSolver extends BaseSolver {
      * the other, never both.
      */
     private getSupersededNetLabelKeys;
+    private getOutputTraces;
     getOutput(): {
         traces: SolvedTracePath[];
         netLabelPlacements: NetLabelPlacement[];

package/dist/index.js

@@ -8842,13 +8842,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   findValidTraceAnchorCandidate(label, orientation, labelIndex) {
     const direction = dir(orientation);
-    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
-      (a, b) => {
-        const aAlongDirection = a.x * direction.x + a.y * direction.y;
-        const bAlongDirection = b.x * direction.x + b.y * direction.y;
-        return bAlongDirection - aAlongDirection;
-      }
-    );
+    const candidatePoints = this.getTraceAnchorCandidatePoints(
+      label,
+      orientation
+    ).sort((a, b) => {
+      const aAlongDirection = a.x * direction.x + a.y * direction.y;
+      const bAlongDirection = b.x * direction.x + b.y * direction.y;
+      return bAlongDirection - aAlongDirection;
+    });
     for (const anchorPoint of candidatePoints) {
       const candidate = this.createCandidate(label, anchorPoint, orientation);
       const result = this.evaluateCandidate(
@@ -8867,13 +8868,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   findValidOutwardTraceAnchorCandidate(label, orientation, labelIndex) {
     const direction = dir(orientation);
-    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
-      (a, b) => {
-        const aAlongDirection = a.x * direction.x + a.y * direction.y;
-        const bAlongDirection = b.x * direction.x + b.y * direction.y;
-        return bAlongDirection - aAlongDirection;
-      }
-    );
+    const candidatePoints = this.getTraceAnchorCandidatePoints(
+      label,
+      orientation
+    ).sort((a, b) => {
+      const aAlongDirection = a.x * direction.x + a.y * direction.y;
+      const bAlongDirection = b.x * direction.x + b.y * direction.y;
+      return bAlongDirection - aAlongDirection;
+    });
     for (const connectorSource of candidatePoints) {
       const preservedColumnAnchor = this.getSearchStartAnchor(
         label,
@@ -8931,10 +8933,40 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  getTraceAnchorCandidatePoints(label) {
+  getTraceAnchorCandidatePoints(label, orientation) {
     const seen = /* @__PURE__ */ new Set();
     const points = [];
-    for (const traceId of label.mspConnectionPairIds ?? []) {
+    const connectedTraceIds = new Set(label.mspConnectionPairIds ?? []);
+    if (isYOrientation(orientation)) {
+      const connectedPinIds = /* @__PURE__ */ new Set();
+      for (const traceId of connectedTraceIds) {
+        for (const pinId of this.traceMap[traceId]?.pinIds ?? []) {
+          connectedPinIds.add(pinId);
+        }
+      }
+      let foundConnectedTrace = true;
+      while (foundConnectedTrace) {
+        foundConnectedTrace = false;
+        for (const trace of Object.values(this.traceMap)) {
+          if (connectedTraceIds.has(trace.mspPairId)) continue;
+          if (trace.mspPairId.startsWith("available-net-orientation-")) continue;
+          if (trace.globalConnNetId !== label.globalConnNetId) continue;
+          if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId)))
+            continue;
+          const connectedTraces = [...connectedTraceIds].flatMap((traceId) => {
+            const connectedTrace = this.traceMap[traceId];
+            return connectedTrace ? [connectedTrace] : [];
+          });
+          if (!this.sharesVerticalRailWithAny(trace, connectedTraces)) {
+            continue;
+          }
+          connectedTraceIds.add(trace.mspPairId);
+          for (const pinId of trace.pinIds) connectedPinIds.add(pinId);
+          foundConnectedTrace = true;
+        }
+      }
+    }
+    for (const traceId of connectedTraceIds) {
       const trace = this.traceMap[traceId];
       if (!trace) continue;
       for (const point of trace.tracePath) {
@@ -8946,6 +8978,26 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return points;
   }
+  sharesVerticalRailWithAny(trace, otherTraces) {
+    const verticalRailXs = /* @__PURE__ */ new Set();
+    for (const otherTrace of otherTraces) {
+      for (let i = 0; i < otherTrace.tracePath.length - 1; i++) {
+        const start = otherTrace.tracePath[i];
+        const end = otherTrace.tracePath[i + 1];
+        if (Math.abs(start.x - end.x) <= EPS12 && Math.abs(start.y - end.y) > EPS12) {
+          verticalRailXs.add(start.x);
+        }
+      }
+    }
+    for (let i = 0; i < trace.tracePath.length - 1; i++) {
+      const start = trace.tracePath[i];
+      const end = trace.tracePath[i + 1];
+      if (Math.abs(start.x - end.x) <= EPS12 && Math.abs(start.y - end.y) > EPS12 && [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS12)) {
+        return true;
+      }
+    }
+    return false;
+  }
   getAvailableOrientations(label) {
     const effectiveNetId = label.netId ?? label.globalConnNetId;
     return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? [];
@@ -12576,6 +12628,154 @@ var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
   return segments.sort((a, b) => b.length - a.length);
 };
 
+// lib/solvers/InlineNetLabelSolver/alignPortOnlyInlineNetLabelStubs.ts
+var getStubDirection = (path) => {
+  const [start, end] = path;
+  if (Math.abs(end.x - start.x) >= Math.abs(end.y - start.y)) {
+    return end.x >= start.x ? "x+" : "x-";
+  }
+  return end.y >= start.y ? "y+" : "y-";
+};
+var getStubLength = (path) => {
+  const [start, end] = path;
+  return Math.abs(end.x - start.x) + Math.abs(end.y - start.y);
+};
+var getLabelBounds2 = (placement) => {
+  const isVertical5 = placement.axis === "y";
+  const width = isVertical5 ? placement.height : placement.width;
+  const height = isVertical5 ? placement.width : placement.height;
+  return {
+    minX: placement.center.x - width / 2,
+    maxX: placement.center.x + width / 2,
+    minY: placement.center.y - height / 2,
+    maxY: placement.center.y + height / 2
+  };
+};
+var getPathBounds = (path) => ({
+  minX: Math.min(...path.map((point) => point.x)),
+  maxX: Math.max(...path.map((point) => point.x)),
+  minY: Math.min(...path.map((point) => point.y)),
+  maxY: Math.max(...path.map((point) => point.y))
+});
+var doesPathIntersectBounds = (path, bounds) => {
+  for (let index = 0; index < path.length - 1; index++) {
+    const segmentBounds = getPathBounds([path[index], path[index + 1]]);
+    if (boundsOverlap(segmentBounds, bounds)) return true;
+  }
+  return false;
+};
+var resizeStub = (placement, direction, targetLength) => {
+  const [start] = placement.stubTracePath;
+  const end = direction === "x+" ? { x: start.x + targetLength, y: start.y } : direction === "x-" ? { x: start.x - targetLength, y: start.y } : direction === "y+" ? { x: start.x, y: start.y + targetLength } : { x: start.x, y: start.y - targetLength };
+  const anchorPoint = {
+    x: (start.x + end.x) / 2,
+    y: (start.y + end.y) / 2
+  };
+  return {
+    ...placement,
+    stubTracePath: [start, end],
+    anchorPoint,
+    // Extending a short row only adds wire at its free end. Keep the label
+    // itself next to the pin so terminal labels can be start/end aligned and
+    // collision checks continue to describe the rendered text box.
+    center: placement.center
+  };
+};
+var alignPortOnlyInlineNetLabelStubs = ({
+  placements,
+  inputProblem,
+  traces,
+  netLabelPlacements
+}) => {
+  const chipIdByPinId = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) chipIdByPinId.set(pin.pinId, chip.chipId);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const [placementIndex, placement] of placements.entries()) {
+    if (!placement.stubTracePath || placement.pinIds.length !== 1) continue;
+    const direction = getStubDirection(placement.stubTracePath);
+    if (!direction) continue;
+    const ownerChipId = chipIdByPinId.get(placement.pinIds[0]);
+    const groupKey = `${ownerChipId ?? placement.pinIds[0]}::${direction}`;
+    const group = groups.get(groupKey) ?? [];
+    group.push({ placementIndex, placement, direction, ownerChipId });
+    groups.set(groupKey, group);
+  }
+  const alignedPlacements = [...placements];
+  const supersededGlobalNetIds = new Set(
+    placements.map((placement) => placement.globalConnNetId)
+  );
+  const retainedAnchoredLabelBounds = netLabelPlacements.filter(
+    (placement) => !supersededGlobalNetIds.has(placement.globalConnNetId)
+  ).map(getLabelBounds2);
+  for (const group of groups.values()) {
+    if (group.length < 2) continue;
+    const targetLength = Math.max(
+      ...group.map(({ placement }) => getStubLength(placement.stubTracePath))
+    );
+    const proposals = group.map(
+      ({ placement, direction }) => resizeStub(placement, direction, targetLength)
+    );
+    const groupPlacementIndices = new Set(
+      group.map(({ placementIndex }) => placementIndex)
+    );
+    const fixedInlinePlacements = placements.filter(
+      (_, placementIndex) => !groupPlacementIndices.has(placementIndex)
+    );
+    const hasConflict = proposals.some((proposal, proposalIndex) => {
+      const labelBounds = getLabelBounds2(proposal);
+      const stubPath = proposal.stubTracePath;
+      const stubBounds = getPathBounds(stubPath);
+      const ownerChipId = group[proposalIndex].ownerChipId;
+      for (const chip of inputProblem.chips) {
+        const chipBounds = {
+          minX: chip.center.x - chip.width / 2,
+          maxX: chip.center.x + chip.width / 2,
+          minY: chip.center.y - chip.height / 2,
+          maxY: chip.center.y + chip.height / 2
+        };
+        if (boundsOverlap(labelBounds, chipBounds)) return true;
+        if (chip.chipId !== ownerChipId && boundsOverlap(stubBounds, chipBounds))
+          return true;
+      }
+      for (const textBox of inputProblem.textBoxes ?? []) {
+        const textBounds = getTextBoxBounds(textBox);
+        if (boundsOverlap(labelBounds, textBounds) || boundsOverlap(stubBounds, textBounds))
+          return true;
+      }
+      for (const trace of traces) {
+        if (trace.globalConnNetId === proposal.globalConnNetId) continue;
+        if (doesPathIntersectBounds(trace.tracePath, labelBounds) || doesPathIntersectBounds(trace.tracePath, stubBounds))
+          return true;
+      }
+      if (retainedAnchoredLabelBounds.some(
+        (bounds) => boundsOverlap(labelBounds, bounds) || boundsOverlap(stubBounds, bounds)
+      ))
+        return true;
+      for (const fixedPlacement of fixedInlinePlacements) {
+        const fixedLabelBounds = getLabelBounds2(fixedPlacement);
+        if (boundsOverlap(labelBounds, fixedLabelBounds) || boundsOverlap(stubBounds, fixedLabelBounds))
+          return true;
+        if (fixedPlacement.stubTracePath && (doesPathIntersectBounds(fixedPlacement.stubTracePath, labelBounds) || doesPathIntersectBounds(stubPath, fixedLabelBounds)))
+          return true;
+      }
+      for (const [otherIndex, otherProposal] of proposals.entries()) {
+        if (otherIndex === proposalIndex) continue;
+        const otherLabelBounds = getLabelBounds2(otherProposal);
+        if (boundsOverlap(labelBounds, otherLabelBounds)) return true;
+        if (doesPathIntersectBounds(stubPath, otherLabelBounds)) return true;
+      }
+      return false;
+    });
+    if (hasConflict) continue;
+    for (const [groupIndex, { placementIndex }] of group.entries()) {
+      alignedPlacements[placementIndex] = proposals[groupIndex];
+    }
+  }
+  return alignedPlacements;
+};
+
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
@@ -12588,7 +12788,10 @@ var InlineNetLabelSolver = class extends BaseSolver {
   inlineNetLabelPlacements = [];
   /** Direct connections that opted in, still waiting to be processed */
   queuedDirectConnections;
+  /** Single-pin net connections that opted in, still waiting to be processed */
+  queuedPortOnlyNetConnections;
   tracesByPinPairKey;
+  hasAlignedPortOnlyStubs = false;
   constructor(input) {
     super();
     this.inputProblem = input.inputProblem;
@@ -12597,6 +12800,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
     this.queuedDirectConnections = this.inputProblem.directConnections.filter(
       (dc) => dc.allowInlineNetLabel && dc.netId
     );
+    this.queuedPortOnlyNetConnections = this.inputProblem.netConnections.filter(
+      (nc) => nc.allowInlineNetLabel && nc.pinIds.length === 1 && nc.netId
+    );
     this.tracesByPinPairKey = /* @__PURE__ */ new Map();
     for (const trace of this.traces) {
       const key = getPinPairKey2(trace.pins.map((p) => p.pinId));
@@ -12619,15 +12825,97 @@ var InlineNetLabelSolver = class extends BaseSolver {
   }
   _step() {
     const directConnection = this.queuedDirectConnections.shift();
-    if (!directConnection) {
-      this.solved = true;
-      this.stats.inlineNetLabelCount = this.inlineNetLabelPlacements.length;
+    if (directConnection) {
+      const placement = this.computeInlinePlacement(directConnection);
+      if (placement) {
+        this.inlineNetLabelPlacements.push(placement);
+      }
+      return;
+    }
+    const portOnlyNetConnection = this.queuedPortOnlyNetConnections.shift();
+    if (portOnlyNetConnection) {
+      const placement = this.computePortOnlyInlinePlacement(
+        portOnlyNetConnection
+      );
+      if (placement) {
+        this.inlineNetLabelPlacements.push(placement);
+      }
+      return;
+    }
+    if (!this.hasAlignedPortOnlyStubs) {
+      this.inlineNetLabelPlacements = alignPortOnlyInlineNetLabelStubs({
+        placements: this.inlineNetLabelPlacements,
+        inputProblem: this.inputProblem,
+        traces: this.traces,
+        netLabelPlacements: this.inputNetLabelPlacements
+      });
+      this.hasAlignedPortOnlyStubs = true;
       return;
     }
-    const placement = this.computeInlinePlacement(directConnection);
-    if (placement) {
-      this.inlineNetLabelPlacements.push(placement);
+    this.solved = true;
+    this.stats.inlineNetLabelCount = this.inlineNetLabelPlacements.length;
+  }
+  /**
+   * Converts a conventional port-only anchored placement into an inline label
+   * on a generated outward stub. The stub follows the pin's true facing
+   * direction; an anchored label may finish in another direction after an
+   * elbow, which is not the direction a terminal stub should leave the pin.
+   */
+  computePortOnlyInlinePlacement(netConnection) {
+    const [pinId] = netConnection.pinIds;
+    if (!pinId) return null;
+    const anchoredPlacement = this.inputNetLabelPlacements.find(
+      (placement) => placement.netId === netConnection.netId && placement.pinIds.length === 1 && placement.pinIds[0] === pinId
+    );
+    if (!anchoredPlacement) return null;
+    const inputChip = this.inputProblem.chips.find(
+      (chip) => chip.pins.some((pin) => pin.pinId === pinId)
+    );
+    const inputPin = inputChip?.pins.find((pin) => pin.pinId === pinId);
+    const height = netConnection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
+    const width = netConnection.inlineNetLabelWidth ?? netConnection.netLabelWidth ?? estimateInlineNetLabelWidth(netConnection.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;
+    const end = direction === "x+" ? { x: start.x + stubLength, y: start.y } : direction === "x-" ? { x: start.x - stubLength, y: start.y } : direction === "y+" ? { x: start.x, y: start.y + stubLength } : { x: start.x, y: start.y - stubLength };
+    const axis = direction === "x+" || direction === "x-" ? "x" : "y";
+    const side = axis === "x" ? "y+" : "x-";
+    const anchorPoint = {
+      x: (start.x + end.x) / 2,
+      y: (start.y + end.y) / 2
+    };
+    const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN;
+    const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset } : { x: anchorPoint.x - offset, y: anchorPoint.y };
+    const halfAlong = width / 2;
+    const halfAcross = height / 2;
+    const bounds = axis === "x" ? {
+      minX: center.x - halfAlong,
+      maxX: center.x + halfAlong,
+      minY: center.y - halfAcross,
+      maxY: center.y + halfAcross
+    } : {
+      minX: center.x - halfAcross,
+      maxX: center.x + halfAcross,
+      minY: center.y - halfAlong,
+      maxY: center.y + halfAlong
+    };
+    if (this.isObstructed(bounds, {
+      ownGlobalConnNetId: anchoredPlacement.globalConnNetId
+    })) {
+      return null;
     }
+    return {
+      globalConnNetId: anchoredPlacement.globalConnNetId,
+      netId: netConnection.netId,
+      pinIds: [pinId],
+      stubTracePath: [start, end],
+      axis,
+      anchorPoint,
+      center,
+      width,
+      height,
+      side
+    };
   }
   computeInlinePlacement(directConnection) {
     const traces = this.tracesByPinPairKey.get(getPinPairKey2(directConnection.pinIds)) ?? [];
@@ -12657,7 +12945,11 @@ var InlineNetLabelSolver = class extends BaseSolver {
             minY: center.y - halfAlong,
             maxY: center.y + halfAlong
           };
-          if (this.isObstructed(bounds, trace)) continue;
+          if (this.isObstructed(bounds, {
+            ownTrace: trace,
+            ownGlobalConnNetId: trace.globalConnNetId
+          }))
+            continue;
           return {
             globalConnNetId: trace.globalConnNetId,
             netId: directConnection.netId,
@@ -12742,7 +13034,11 @@ var InlineNetLabelSolver = class extends BaseSolver {
           minY: center.y - halfAlong,
           maxY: center.y + halfAlong
         };
-        if (this.isObstructed(bounds, trace)) continue;
+        if (this.isObstructed(bounds, {
+          ownTrace: trace,
+          ownGlobalConnNetId: trace.globalConnNetId
+        }))
+          continue;
         const anchorPoint = axis === "x" ? { x: along, y: side === "y+" ? maxY : minY } : { x: side === "x-" ? minX : maxX, y: along };
         return {
           globalConnNetId: trace.globalConnNetId,
@@ -12764,7 +13060,10 @@ var InlineNetLabelSolver = class extends BaseSolver {
    * An inline label may not sit on top of a chip, a component's text, or a
    * trace belonging to another net.
    */
-  isObstructed(bounds, ownTrace) {
+  isObstructed(bounds, {
+    ownTrace,
+    ownGlobalConnNetId
+  }) {
     for (const chip of this.inputProblem.chips) {
       const chipBounds = {
         minX: chip.center.x - chip.width / 2,
@@ -12778,9 +13077,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
       if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
     }
     for (const trace of this.traces) {
-      if (trace.mspPairId === ownTrace.mspPairId) continue;
-      if (trace.globalConnNetId === ownTrace.globalConnNetId) continue;
-      if (doesPathIntersectBounds(trace.tracePath, bounds)) return true;
+      if (ownTrace && trace.mspPairId === ownTrace.mspPairId) continue;
+      if (trace.globalConnNetId === ownGlobalConnNetId) continue;
+      if (doesPathIntersectBounds2(trace.tracePath, bounds)) return true;
     }
     return false;
   }
@@ -12795,10 +13094,18 @@ var InlineNetLabelSolver = class extends BaseSolver {
     }
     return keys;
   }
+  getOutputTraces(supersededNetLabelKeys) {
+    return this.traces.filter(
+      (trace) => !(supersededNetLabelKeys.has(trace.globalConnNetId) && trace.mspPairId.startsWith("available-net-orientation-"))
+    );
+  }
   getOutput() {
     const superseded = this.getSupersededNetLabelKeys();
     return {
-      traces: this.traces,
+      // AvailableNetOrientationSolver may have routed an elbow from a port to
+      // the anchored label that this inline placement supersedes. Keep the
+      // actual net trace, but discard that now-orphaned label connector.
+      traces: this.getOutputTraces(superseded),
       netLabelPlacements: this.inputNetLabelPlacements.filter(
         (placement) => !superseded.has(placement.globalConnNetId)
       ),
@@ -12811,7 +13118,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
     graphics.rects ??= [];
     graphics.points ??= [];
     graphics.texts ??= [];
-    for (const trace of this.traces) {
+    const output = this.getOutput();
+    for (const trace of output.traces) {
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "purple"
@@ -12837,6 +13145,12 @@ orientation: ${label.orientation}`
       });
     }
     for (const inlineLabel of this.inlineNetLabelPlacements) {
+      if (inlineLabel.stubTracePath) {
+        graphics.lines.push({
+          points: inlineLabel.stubTracePath,
+          strokeColor: "purple"
+        });
+      }
       const isHorizontal4 = inlineLabel.axis === "x";
       graphics.rects.push({
         center: inlineLabel.center,
@@ -12851,12 +13165,12 @@ orientation: ${label.orientation}`
         ].join("\n")
       });
       graphics.texts.push({
-        x: inlineLabel.center.x,
-        y: inlineLabel.center.y,
+        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: "center",
+        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
       });
@@ -12891,7 +13205,7 @@ var getAnchorCandidates = (segment, labelWidth, step = 0.1) => {
   offsets.push(slack / 2, -slack / 2);
   return offsets.map((offset) => pointAt(mid + offset * direction));
 };
-var doesPathIntersectBounds = (path, bounds) => {
+var doesPathIntersectBounds2 = (path, bounds) => {
   for (let i = 0; i < path.length - 1; i++) {
     const a = path[i];
     const b = path[i + 1];