@tscircuit/schematic-trace-solver 0.0.143 → 0.0.145

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. */
@@ -143,6 +146,8 @@ type MspConnectionPair = {
     dcConnNetId: string;
     globalConnNetId: string;
     userNetId?: string;
+    /** The trace replaces fallback labels that could not fit between its pins. */
+    suppressNetLabel?: boolean;
     pins: [InputPin & {
         chipId: string;
     }, InputPin & {
@@ -1200,8 +1205,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 */
@@ -1226,9 +1232,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.
@@ -1238,22 +1246,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

@@ -420,8 +420,48 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   return edges;
 }
 
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
+var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
+var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
+function getDimsForOrientation(params) {
+  const { orientation, netLabelWidth, netLabelHeight } = params;
+  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
+  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
+  if (orientation === "y+" || orientation === "y-") {
+    return {
+      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
+      width: horizHeight,
+      height: horizWidth
+    };
+  }
+  return {
+    width: horizWidth,
+    height: horizHeight
+  };
+}
+function getCenterFromAnchor(anchor, orientation, width, height) {
+  switch (orientation) {
+    case "x+":
+      return { x: anchor.x + width / 2, y: anchor.y };
+    case "x-":
+      return { x: anchor.x - width / 2, y: anchor.y };
+    case "y+":
+      return { x: anchor.x, y: anchor.y + height / 2 };
+    case "y-":
+      return { x: anchor.x, y: anchor.y - height / 2 };
+  }
+}
+function getRectBounds(center, w, h) {
+  return {
+    minX: center.x - w / 2,
+    minY: center.y - h / 2,
+    maxX: center.x + w / 2,
+    maxY: center.y + h / 2
+  };
+}
+
 // lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts
-var isLabeledPeripheralConnection = ({
+var getLabeledConnectionRouteReason = ({
   inputProblem,
   chipMap,
   pins
@@ -430,12 +470,10 @@ var isLabeledPeripheralConnection = ({
   const directConnection = inputProblem.directConnections.find(
     (connection) => connection.pinIds.includes(firstPin.pinId) && connection.pinIds.includes(secondPin.pinId)
   );
-  if (directConnection?.netLabelWidth === void 0) return false;
+  if (directConnection?.netLabelWidth === void 0) return null;
   const firstChip = chipMap[firstPin.chipId];
   const secondChip = chipMap[secondPin.chipId];
-  if (!firstChip || !secondChip) return false;
-  const hasSinglePinPeripheral = firstChip.pins.length === 1 || secondChip.pins.length === 1;
-  if (!hasSinglePinPeripheral) return false;
+  if (!firstChip || !secondChip) return null;
   let firstFacingDirection = firstPin._facingDirection;
   if (!firstFacingDirection) {
     firstFacingDirection = getPinDirection(firstPin, firstChip);
@@ -444,8 +482,20 @@ var isLabeledPeripheralConnection = ({
   if (!secondFacingDirection) {
     secondFacingDirection = getPinDirection(secondPin, secondChip);
   }
-  return firstFacingDirection === "x-" && secondFacingDirection === "x+" || firstFacingDirection === "x+" && secondFacingDirection === "x-";
-};
+  const hasOpposingHorizontalDirections = firstFacingDirection === "x-" && secondFacingDirection === "x+" || firstFacingDirection === "x+" && secondFacingDirection === "x-";
+  if (!hasOpposingHorizontalDirections) return null;
+  const hasSinglePinPeripheral = firstChip.pins.length === 1 || secondChip.pins.length === 1;
+  if (hasSinglePinPeripheral) return "single-pin-peripheral";
+  const sharedSectionId = firstChip.sectionId && firstChip.sectionId === secondChip.sectionId ? firstChip.sectionId : null;
+  if (!sharedSectionId) return null;
+  const firstIsLeft = firstPin.x <= secondPin.x;
+  const directionsPointTowardEachOther = firstIsLeft ? firstFacingDirection === "x+" && secondFacingDirection === "x-" : firstFacingDirection === "x-" && secondFacingDirection === "x+";
+  const labelsOverlapAlongX = Math.abs(firstPin.x - secondPin.x) < directConnection.netLabelWidth * 2;
+  const labelsOverlapAlongY = Math.abs(firstPin.y - secondPin.y) < NET_LABEL_HORIZONTAL_HEIGHT;
+  const fallbackLabelsOverlap = directionsPointTowardEachOther && labelsOverlapAlongX && labelsOverlapAlongY;
+  return fallbackLabelsOverlap ? "overlapping-fallback-labels" : null;
+};
+var isLabeledPeripheralConnection = (params) => getLabeledConnectionRouteReason(params) !== null;
 
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
 var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
@@ -520,12 +570,12 @@ var MspConnectionPairSolver = class extends BaseSolver {
       if (this.directConnectionPinPairKeys.has(pinPairKey)) {
         pairDistance = distance(p1, p2);
       }
-      const isLabeledPeripheral = isLabeledPeripheralConnection({
+      const labeledConnectionRouteReason = getLabeledConnectionRouteReason({
         inputProblem: this.inputProblem,
         chipMap: this.chipMap,
         pins: [p1, p2]
       });
-      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
+      if (pairDistance > this.maxMspPairDistance && !labeledConnectionRouteReason) {
         return;
       }
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
@@ -543,11 +593,13 @@ var MspConnectionPairSolver = class extends BaseSolver {
       }
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1);
       const userNetId = this.userNetIdByPinId[pin1] ?? this.userNetIdByPinId[pin2];
+      const suppressNetLabel = pairDistance > this.maxMspPairDistance && labeledConnectionRouteReason === "overlapping-fallback-labels";
       this.mspConnectionPairs.push({
         mspPairId: `${pin1}-${pin2}`,
         dcConnNetId: dcNetId,
         globalConnNetId,
         userNetId,
+        suppressNetLabel,
         pins: [p1, p2]
       });
       return;
@@ -626,46 +678,6 @@ import "graphics-debug";
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 import { calculateElbow as calculateElbow2 } from "calculate-elbow";
 
-// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
-var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
-var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
-function getDimsForOrientation(params) {
-  const { orientation, netLabelWidth, netLabelHeight } = params;
-  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
-  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
-  if (orientation === "y+" || orientation === "y-") {
-    return {
-      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
-      width: horizHeight,
-      height: horizWidth
-    };
-  }
-  return {
-    width: horizWidth,
-    height: horizHeight
-  };
-}
-function getCenterFromAnchor(anchor, orientation, width, height) {
-  switch (orientation) {
-    case "x+":
-      return { x: anchor.x + width / 2, y: anchor.y };
-    case "x-":
-      return { x: anchor.x - width / 2, y: anchor.y };
-    case "y+":
-      return { x: anchor.x, y: anchor.y + height / 2 };
-    case "y-":
-      return { x: anchor.x, y: anchor.y - height / 2 };
-  }
-}
-function getRectBounds(center, w, h) {
-  return {
-    minX: center.x - w / 2,
-    minY: center.y - h / 2,
-    maxX: center.x + w / 2,
-    maxY: center.y + h / 2
-  };
-}
-
 // lib/utils/textBoxBounds.ts
 function getTextBoxBounds(textBox, padding = {}) {
   return {
@@ -3148,6 +3160,7 @@ var NetLabelPlacementSolver = class extends BaseSolver {
           (t) => component.has(t.pins[0].pinId) && component.has(t.pins[1].pinId)
         );
         if (compTraces.length > 0) {
+          if (compTraces.some((trace) => trace.suppressNetLabel)) continue;
           const lengthOf = (path) => {
             let sum = 0;
             const pts = path.tracePath;
@@ -12786,10 +12799,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) {
@@ -12797,12 +12808,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));
@@ -12824,21 +12837,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;
     }
@@ -12856,24 +12867,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;
@@ -12906,7 +12916,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     }
     return {
       globalConnNetId: anchoredPlacement.globalConnNetId,
-      netId: netConnection.netId,
+      netId: connection.netId,
       pinIds: [pinId],
       stubTracePath: [start, end],
       axis,
@@ -12917,14 +12927,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) {
@@ -12952,9 +12962,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,
@@ -12967,7 +12977,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     }
     const spanPlacement = this.computeSpanPlacement({
       trace,
-      directConnection,
+      connection,
       width,
       height,
       offset
@@ -12983,7 +12993,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
    */
   computeSpanPlacement({
     trace,
-    directConnection,
+    connection,
     width,
     height,
     offset
@@ -13042,9 +13052,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,