@tscircuit/schematic-trace-solver 0.0.142 → 0.0.144

package/dist/index.d.ts

@@ -96,7 +96,9 @@ interface InputDirectConnection {
      *
      * Only set this for connections whose net name is worth showing on the wire -
      * the solver trusts the caller (e.g. @tscircuit/core) to make that decision.
-     * An inline label is only emitted when the connection actually got routed.
+     * When the connection is routed, the label is placed along the trace. If
+     * routing is intentionally skipped, both endpoint labels may instead become
+     * outward inline stubs.
      */
     allowInlineNetLabel?: boolean;
     /**
@@ -116,9 +118,10 @@ interface InputNetConnection {
     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.
+     * When true, a named one- or two-pin net may use inline labels. A single-pin
+     * net gets an outward stub. A routed two-pin net gets one label along its
+     * trace; when that route is intentionally skipped, both endpoints get
+     * outward stubs. Nets with more than two pins retain anchored labels.
      */
     allowInlineNetLabel?: boolean;
     /** Extent of the inline text along the generated trace stub. */
@@ -825,6 +828,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private findValidTraceAnchorCandidate;
     private findValidOutwardTraceAnchorCandidate;
     private getTraceAnchorCandidatePoints;
+    private sharesVerticalRailWithAny;
     private getAvailableOrientations;
     private findValidShiftedCandidate;
     /**
@@ -1199,8 +1203,9 @@ interface InlineNetLabelPlacement {
     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.
+     * A generated single-ended trace stub. Present for a single-pin net or for
+     * one endpoint of an unrouted two-pin net; 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 */
@@ -1225,9 +1230,11 @@ interface InlineNetLabelSolverInput {
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
 }
+type InlineEligibleConnection = InputDirectConnection | InputNetConnection;
 /**
  * Places "inline net labels" - net names drawn alongside the trace they belong
- * to - for direct connections that opted in via `allowInlineNetLabel`.
+ * to - for one- or two-pin connections that opted in via
+ * `allowInlineNetLabel`.
  *
  * Any regular (anchored) net label placement for the same net is dropped, so a
  * net is never labeled twice.
@@ -1237,22 +1244,20 @@ declare class InlineNetLabelSolver extends BaseSolver {
     traces: SolvedTracePath[];
     inputNetLabelPlacements: NetLabelPlacement[];
     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[];
+    /** Eligible one- or two-pin connections still waiting to be processed. */
+    queuedConnections: InlineEligibleConnection[];
     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.
+     * Converts one conventional endpoint 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 computeTerminalInlinePlacement;
     private computeInlinePlacement;
     /**
      * Places the label over the whole route when the route is straight except

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] ?? [];
@@ -12734,10 +12786,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
   traces;
   inputNetLabelPlacements;
   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;
+  /** Eligible one- or two-pin connections still waiting to be processed. */
+  queuedConnections;
   tracesByPinPairKey;
   hasAlignedPortOnlyStubs = false;
   constructor(input) {
@@ -12745,12 +12795,14 @@ var InlineNetLabelSolver = class extends BaseSolver {
     this.inputProblem = input.inputProblem;
     this.traces = input.traces;
     this.inputNetLabelPlacements = input.netLabelPlacements;
-    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.queuedConnections = [
+      ...this.inputProblem.directConnections.filter(
+        (connection) => connection.allowInlineNetLabel && connection.netId
+      ),
+      ...this.inputProblem.netConnections.filter(
+        (connection) => connection.allowInlineNetLabel && connection.pinIds.length >= 1 && connection.pinIds.length <= 2 && connection.netId
+      )
+    ];
     this.tracesByPinPairKey = /* @__PURE__ */ new Map();
     for (const trace of this.traces) {
       const key = getPinPairKey2(trace.pins.map((p) => p.pinId));
@@ -12772,21 +12824,19 @@ var InlineNetLabelSolver = class extends BaseSolver {
     ];
   }
   _step() {
-    const directConnection = this.queuedDirectConnections.shift();
-    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);
+    const connection = this.queuedConnections.shift();
+    if (connection) {
+      const routedTraces = connection.pinIds.length === 2 ? this.tracesByPinPairKey.get(getPinPairKey2(connection.pinIds)) ?? [] : [];
+      if (routedTraces.length > 0) {
+        const placement = this.computeInlinePlacement(connection);
+        if (placement) this.inlineNetLabelPlacements.push(placement);
+      } else {
+        const terminalPlacements = connection.pinIds.map(
+          (pinId) => this.computeTerminalInlinePlacement(connection, pinId)
+        );
+        if (terminalPlacements.every((placement) => placement !== null)) {
+          this.inlineNetLabelPlacements.push(...terminalPlacements);
+        }
       }
       return;
     }
@@ -12804,24 +12854,23 @@ var InlineNetLabelSolver = class extends BaseSolver {
     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.
+   * Converts one conventional endpoint 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;
+  computeTerminalInlinePlacement(connection, pinId) {
+    if (!connection.netId) return null;
     const anchoredPlacement = this.inputNetLabelPlacements.find(
-      (placement) => placement.netId === netConnection.netId && placement.pinIds.length === 1 && placement.pinIds[0] === pinId
+      (placement) => placement.netId === connection.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 height = connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
+    const width = connection.inlineNetLabelWidth ?? connection.netLabelWidth ?? estimateInlineNetLabelWidth(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;
@@ -12854,7 +12903,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     }
     return {
       globalConnNetId: anchoredPlacement.globalConnNetId,
-      netId: netConnection.netId,
+      netId: connection.netId,
       pinIds: [pinId],
       stubTracePath: [start, end],
       axis,
@@ -12865,14 +12914,14 @@ var InlineNetLabelSolver = class extends BaseSolver {
       side
     };
   }
-  computeInlinePlacement(directConnection) {
-    const traces = this.tracesByPinPairKey.get(getPinPairKey2(directConnection.pinIds)) ?? [];
+  computeInlinePlacement(connection) {
+    const traces = this.tracesByPinPairKey.get(getPinPairKey2(connection.pinIds)) ?? [];
     if (traces.length === 0) return null;
     const trace = traces[0];
     const segments = getAxisAlignedSegments(trace.tracePath);
     if (segments.length === 0) return null;
-    const height = directConnection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
-    const width = directConnection.inlineNetLabelWidth ?? directConnection.netLabelWidth ?? estimateInlineNetLabelWidth(directConnection.netId, height);
+    const height = connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
+    const width = connection.inlineNetLabelWidth ?? connection.netLabelWidth ?? estimateInlineNetLabelWidth(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) {
@@ -12900,9 +12949,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
             continue;
           return {
             globalConnNetId: trace.globalConnNetId,
-            netId: directConnection.netId,
+            netId: connection.netId,
             mspPairId: trace.mspPairId,
-            pinIds: [...directConnection.pinIds],
+            pinIds: [...connection.pinIds],
             axis: segment.axis,
             anchorPoint,
             center,
@@ -12915,7 +12964,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     }
     const spanPlacement = this.computeSpanPlacement({
       trace,
-      directConnection,
+      connection,
       width,
       height,
       offset
@@ -12931,7 +12980,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
    */
   computeSpanPlacement({
     trace,
-    directConnection,
+    connection,
     width,
     height,
     offset
@@ -12990,9 +13039,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
         const anchorPoint = axis === "x" ? { x: along, y: side === "y+" ? maxY : minY } : { x: side === "x-" ? minX : maxX, y: along };
         return {
           globalConnNetId: trace.globalConnNetId,
-          netId: directConnection.netId,
+          netId: connection.netId,
           mspPairId: trace.mspPairId,
-          pinIds: [...directConnection.pinIds],
+          pinIds: [...connection.pinIds],
           axis,
           anchorPoint,
           center,

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -635,13 +635,14 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     labelIndex: number,
   ) {
     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)
@@ -668,13 +669,14 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     labelIndex: number,
   ) {
     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(
@@ -742,11 +744,52 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
-  private getTraceAnchorCandidatePoints(label: NetLabelPlacement) {
+  private getTraceAnchorCandidatePoints(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+  ) {
     const seen = new Set<string>()
     const points: Point[] = []
+    const connectedTraceIds = new Set(label.mspConnectionPairIds ?? [])
+
+    if (isYOrientation(orientation)) {
+      const connectedPinIds = new Set<string>()
+      for (const traceId of connectedTraceIds) {
+        for (const pinId of this.traceMap[traceId]?.pinIds ?? []) {
+          connectedPinIds.add(pinId)
+        }
+      }
+
+      // Multi-pin rails are routed as a chain of pairwise traces. Follow the
+      // pairs only when they share both a pin and an aligned vertical rail,
+      // which identifies one continuous rail. A shared pin alone can join
+      // unrelated branches whose rail offsets are far apart; walking those
+      // branches would extend the label connector across the schematic.
+      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 label.mspConnectionPairIds ?? []) {
+    for (const traceId of connectedTraceIds) {
       const trace = this.traceMap[traceId]
       if (!trace) continue
       for (const point of trace.tracePath) {
@@ -760,6 +803,39 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return points
   }
 
+  private sharesVerticalRailWithAny(
+    trace: SolvedTracePath,
+    otherTraces: SolvedTracePath[],
+  ) {
+    const verticalRailXs = new Set<number>()
+    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) <= EPS &&
+          Math.abs(start.y - end.y) > EPS
+        ) {
+          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) <= EPS &&
+        Math.abs(start.y - end.y) > EPS &&
+        [...verticalRailXs].some((x) => Math.abs(x - start.x) <= EPS)
+      ) {
+        return true
+      }
+    }
+
+    return false
+  }
+
   private getAvailableOrientations(label: NetLabelPlacement) {
     const effectiveNetId = label.netId ?? label.globalConnNetId
     return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? []