@tscircuit/schematic-trace-solver 0.0.140 → 0.0.142

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>;
@@ -279,6 +289,7 @@ declare class TraceOverlapIssueSolver extends BaseSolver {
 }
 
 type ConnNetId = string;
+type TraceState = Record<MspConnectionPairId, SolvedTracePath>;
 /**
  * This solver finds traces that overlap or meet collinearly and aren't
  * connected via the globalConnMap, then shifts them apart in the direction
@@ -308,6 +319,7 @@ declare class TraceOverlapShiftSolver extends BaseSolver {
      */
     traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>>;
     correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath>;
+    recentTraceStates: TraceState[];
     cleanupPhase: "diagonals" | "done" | null;
     constructor(params: {
         inputProblem: InputProblem;
@@ -324,6 +336,8 @@ declare class TraceOverlapShiftSolver extends BaseSolver {
     private findNextDiagonalSegment;
     private findAndFixNextDiagonalSegment;
     _step(): void;
+    private rememberTraceState;
+    private returnsToPreviousTraceState;
     visualize(): graphics_debug.GraphicsObject;
 }
 
@@ -1182,8 +1196,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 */
@@ -1220,10 +1239,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
@@ -1242,6 +1271,7 @@ declare class InlineNetLabelSolver extends BaseSolver {
      * the other, never both.
      */
     private getSupersededNetLabelKeys;
+    private getOutputTraces;
     getOutput(): {
         traces: SolvedTracePath[];
         netLabelPlacements: NetLabelPlacement[];

package/dist/index.js

@@ -2102,6 +2102,7 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
 };
 
 // lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts
+var TRACE_STATE_POSITION_EPSILON = 1e-6;
 var TraceOverlapShiftSolver = class extends BaseSolver {
   inputProblem;
   inputTracePaths;
@@ -2112,6 +2113,9 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
    */
   traceNetIslands = {};
   correctedTraceMap = {};
+  // Keep only the current and previous layouts to detect a two-state cycle
+  // without accumulating routing history for the whole solve.
+  recentTraceStates = [];
   cleanupPhase = null;
   constructor(params) {
     super();
@@ -2123,6 +2127,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       const { mspPairId } = tracePath;
       this.correctedTraceMap[mspPairId] = tracePath;
     }
+    this.rememberTraceState(this.correctedTraceMap);
     this.traceNetIslands = this.computeTraceNetIslands();
   }
   getConstructorParams() {
@@ -2337,11 +2342,17 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
   }
   _step() {
     if (this.activeSubSolver?.solved) {
-      for (const [mspPairId, newTrace] of Object.entries(
-        this.activeSubSolver.correctedTraceMap
-      )) {
-        this.correctedTraceMap[mspPairId] = newTrace;
+      const nextTraceState = {
+        ...this.correctedTraceMap,
+        ...this.activeSubSolver.correctedTraceMap
+      };
+      if (this.returnsToPreviousTraceState(nextTraceState)) {
+        this.activeSubSolver = null;
+        this.solved = true;
+        return;
       }
+      this.correctedTraceMap = nextTraceState;
+      this.rememberTraceState(nextTraceState);
       this.activeSubSolver = null;
       this.traceNetIslands = this.computeTraceNetIslands();
     }
@@ -2374,6 +2385,34 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       traceIdsToShift: this.traceIdsToShift
     });
   }
+  rememberTraceState(traceState) {
+    this.recentTraceStates.push({ ...traceState });
+    if (this.recentTraceStates.length > 2) {
+      this.recentTraceStates.shift();
+    }
+  }
+  returnsToPreviousTraceState(candidateTraceState) {
+    if (this.recentTraceStates.length < 2) return false;
+    const previousTraceState = this.recentTraceStates[0];
+    const traceIds = Object.keys(candidateTraceState);
+    if (traceIds.length !== Object.keys(previousTraceState).length) return false;
+    for (const traceId of traceIds) {
+      const candidatePath = candidateTraceState[traceId];
+      const previousPath = previousTraceState[traceId];
+      if (!candidatePath || !previousPath) return false;
+      if (candidatePath.tracePath.length !== previousPath.tracePath.length) {
+        return false;
+      }
+      for (let i = 0; i < candidatePath.tracePath.length; i++) {
+        const candidatePoint = candidatePath.tracePath[i];
+        const previousPoint = previousPath.tracePath[i];
+        if (Math.abs(candidatePoint.x - previousPoint.x) > TRACE_STATE_POSITION_EPSILON || Math.abs(candidatePoint.y - previousPoint.y) > TRACE_STATE_POSITION_EPSILON) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
   visualize() {
     if (this.activeSubSolver) {
       return this.activeSubSolver.visualize();
@@ -12537,6 +12576,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;
@@ -12549,7 +12736,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;
@@ -12558,6 +12748,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));
@@ -12580,15 +12773,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 placement = this.computeInlinePlacement(directConnection);
-    if (placement) {
-      this.inlineNetLabelPlacements.push(placement);
+    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;
+    }
+    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)) ?? [];
@@ -12618,7 +12893,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,
@@ -12703,7 +12982,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,
@@ -12725,7 +13008,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,
@@ -12739,9 +13025,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;
   }
@@ -12756,10 +13042,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)
       ),
@@ -12772,7 +13066,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"
@@ -12798,6 +13093,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,
@@ -12812,12 +13113,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
       });
@@ -12852,7 +13153,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];