@tscircuit/schematic-trace-solver 0.0.143 → 0.0.145

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -52,8 +52,9 @@ export interface InlineNetLabelPlacement {
   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]
 
@@ -85,12 +86,15 @@ interface InlineNetLabelSolverInput {
   netLabelPlacements: NetLabelPlacement[]
 }
 
+type InlineEligibleConnection = InputDirectConnection | InputNetConnection
+
 const getPinPairKey = (pinIds: readonly string[]) =>
   [...pinIds].sort().join("::")
 
 /**
  * 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.
@@ -102,11 +106,8 @@ export 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[]
+  /** Eligible one- or two-pin connections still waiting to be processed. */
+  queuedConnections: InlineEligibleConnection[]
 
   private tracesByPinPairKey: Map<string, SolvedTracePath[]>
   private hasAlignedPortOnlyStubs = false
@@ -117,12 +118,18 @@ export class InlineNetLabelSolver extends BaseSolver {
     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 = new Map()
     for (const trace of this.traces) {
@@ -147,22 +154,28 @@ export class InlineNetLabelSolver extends BaseSolver {
   }
 
   override _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(getPinPairKey(connection.pinIds)) ??
+            [])
+          : []
+
+      if (routedTraces.length > 0) {
+        const placement = this.computeInlinePlacement(connection)
+        if (placement) this.inlineNetLabelPlacements.push(placement)
+      } else {
+        // A one-pin net has one conventional endpoint label, while a skipped
+        // two-pin route has one at each endpoint. Convert a two-pin pair
+        // atomically so a collision at one endpoint cannot leave mixed inline
+        // and anchored representations for the same net.
+        const terminalPlacements = connection.pinIds.map((pinId) =>
+          this.computeTerminalInlinePlacement(connection, pinId),
+        )
+        if (terminalPlacements.every((placement) => placement !== null)) {
+          this.inlineNetLabelPlacements.push(...terminalPlacements)
+        }
       }
       return
     }
@@ -183,20 +196,20 @@ export class InlineNetLabelSolver extends BaseSolver {
   }
 
   /**
-   * 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(
-    netConnection: InputNetConnection,
+  private computeTerminalInlinePlacement(
+    connection: InlineEligibleConnection,
+    pinId: PinId,
   ): InlineNetLabelPlacement | null {
-    const [pinId] = netConnection.pinIds
-    if (!pinId) return null
+    if (!connection.netId) return null
 
     const anchoredPlacement = this.inputNetLabelPlacements.find(
       (placement) =>
-        placement.netId === netConnection.netId &&
+        placement.netId === connection.netId &&
         placement.pinIds.length === 1 &&
         placement.pinIds[0] === pinId,
     )
@@ -208,11 +221,11 @@ export class InlineNetLabelSolver extends BaseSolver {
     const inputPin = inputChip?.pins.find((pin) => pin.pinId === pinId)
 
     const height =
-      netConnection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT
+      connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT
     const width =
-      netConnection.inlineNetLabelWidth ??
-      netConnection.netLabelWidth ??
-      estimateInlineNetLabelWidth(netConnection.netId, height)
+      connection.inlineNetLabelWidth ??
+      connection.netLabelWidth ??
+      estimateInlineNetLabelWidth(connection.netId, height)
 
     // Leave a small wire tail at both ends of the text so it unmistakably
     // reads as a label on a trace rather than free-standing text.
@@ -273,7 +286,7 @@ export class InlineNetLabelSolver extends BaseSolver {
 
     return {
       globalConnNetId: anchoredPlacement.globalConnNetId,
-      netId: netConnection.netId,
+      netId: connection.netId,
       pinIds: [pinId],
       stubTracePath: [start, end],
       axis,
@@ -286,12 +299,12 @@ export class InlineNetLabelSolver extends BaseSolver {
   }
 
   private computeInlinePlacement(
-    directConnection: InputDirectConnection,
+    connection: InlineEligibleConnection,
   ): InlineNetLabelPlacement | null {
     // Only connections the router actually drew a trace for can carry an inline
     // label - there's nothing to run parallel to otherwise.
     const traces =
-      this.tracesByPinPairKey.get(getPinPairKey(directConnection.pinIds)) ?? []
+      this.tracesByPinPairKey.get(getPinPairKey(connection.pinIds)) ?? []
     if (traces.length === 0) return null
 
     const trace = traces[0]!
@@ -299,11 +312,11 @@ export class InlineNetLabelSolver extends BaseSolver {
     if (segments.length === 0) return null
 
     const height =
-      directConnection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT
+      connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT
     const width =
-      directConnection.inlineNetLabelWidth ??
-      directConnection.netLabelWidth ??
-      estimateInlineNetLabelWidth(directConnection.netId!, height)
+      connection.inlineNetLabelWidth ??
+      connection.netLabelWidth ??
+      estimateInlineNetLabelWidth(connection.netId!, height)
 
     const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN
 
@@ -360,9 +373,9 @@ export class InlineNetLabelSolver extends BaseSolver {
 
           return {
             globalConnNetId: trace.globalConnNetId,
-            netId: directConnection.netId,
+            netId: connection.netId,
             mspPairId: trace.mspPairId,
-            pinIds: [...directConnection.pinIds],
+            pinIds: [...connection.pinIds],
             axis: segment.axis,
             anchorPoint,
             center,
@@ -380,7 +393,7 @@ export class InlineNetLabelSolver extends BaseSolver {
     // endpoints.
     const spanPlacement = this.computeSpanPlacement({
       trace,
-      directConnection,
+      connection,
       width,
       height,
       offset,
@@ -400,13 +413,13 @@ export class InlineNetLabelSolver extends BaseSolver {
    */
   private computeSpanPlacement({
     trace,
-    directConnection,
+    connection,
     width,
     height,
     offset,
   }: {
     trace: SolvedTracePath
-    directConnection: InputDirectConnection
+    connection: InlineEligibleConnection
     width: number
     height: number
     offset: number
@@ -496,9 +509,9 @@ export class InlineNetLabelSolver extends BaseSolver {
 
         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/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -14,7 +14,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
 import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
-import { isLabeledPeripheralConnection } from "./isLabeledPeripheralConnection"
+import { getLabeledConnectionRouteReason } from "./isLabeledPeripheralConnection"
 
 export type MspConnectionPairId = string
 export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
@@ -26,6 +26,8 @@ export 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 & { chipId: string }]
 }
 
@@ -121,14 +123,17 @@ export class MspConnectionPairSolver extends BaseSolver {
       if (this.directConnectionPinPairKeys.has(pinPairKey)) {
         pairDistance = distance(p1, p2)
       }
-      // Labeled one-pin peripherals need a real trace even when they are far
-      // apart; skipping the MSP pair would leave only the fallback path.
-      const isLabeledPeripheral = isLabeledPeripheralConnection({
+      // Labeled one-pin peripherals and opposed pins whose fallback labels
+      // cannot fit need a real trace even when they are far apart.
+      const labeledConnectionRouteReason = getLabeledConnectionRouteReason({
         inputProblem: this.inputProblem,
         chipMap: this.chipMap,
         pins: [p1, p2],
       })
-      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
+      if (
+        pairDistance > this.maxMspPairDistance &&
+        !labeledConnectionRouteReason
+      ) {
         // Too far apart; skip creating an MSP pair for this net
         return
       }
@@ -155,12 +160,16 @@ export class MspConnectionPairSolver 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],
       })
 

package/lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts

@@ -1,9 +1,14 @@
 import type { InputChip, InputPin, InputProblem } from "lib/types/InputProblem"
+import { NET_LABEL_HORIZONTAL_HEIGHT } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 
 type PinWithChipId = InputPin & { chipId: string }
 
-export const isLabeledPeripheralConnection = ({
+export type LabeledConnectionRouteReason =
+  | "single-pin-peripheral"
+  | "overlapping-fallback-labels"
+
+export const getLabeledConnectionRouteReason = ({
   inputProblem,
   chipMap,
   pins,
@@ -11,22 +16,18 @@ export const isLabeledPeripheralConnection = ({
   inputProblem: InputProblem
   chipMap: Record<string, InputChip>
   pins: [PinWithChipId, PinWithChipId]
-}): boolean => {
+}): LabeledConnectionRouteReason | null => {
   const [firstPin, secondPin] = pins
   const directConnection = inputProblem.directConnections.find(
     (connection) =>
       connection.pinIds.includes(firstPin.pinId) &&
       connection.pinIds.includes(secondPin.pinId),
   )
-  if (directConnection?.netLabelWidth === undefined) return false
+  if (directConnection?.netLabelWidth === undefined) 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) {
@@ -37,8 +38,43 @@ export const isLabeledPeripheralConnection = ({
     secondFacingDirection = getPinDirection(secondPin, secondChip)
   }
 
-  return (
+  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"
+
+  // The overlap fallback is intended for explicitly grouped schematic
+  // sections, where hierarchy boxes and their nearby connectors are laid out
+  // as one visual unit. Applying it to ordinary sheets can reroute unrelated
+  // component-to-component labels elsewhere in the design.
+  const sharedSectionId =
+    firstChip.sectionId && firstChip.sectionId === secondChip.sectionId
+      ? firstChip.sectionId
+      : null
+  if (!sharedSectionId) return null
+
+  // When two multi-pin components face each other across a short gap, the
+  // fallback label at each pin can be wider than the available space. Route
+  // the explicit connection instead of rendering two copies of the long net
+  // name on top of one another.
+  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
 }
+
+export const isLabeledPeripheralConnection = (
+  params: Parameters<typeof getLabeledConnectionRouteReason>[0],
+) => getLabeledConnectionRouteReason(params) !== null

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -188,6 +188,13 @@ export class NetLabelPlacementSolver extends BaseSolver {
         )
 
         if (compTraces.length > 0) {
+          // This routed trace exists specifically because two endpoint labels
+          // could not fit in the available gap. Do not replace that pair with
+          // one redundant long label on the newly routed wire. If routing had
+          // failed there would be no trace here, so the port-only fallback
+          // branch below would still label both endpoints.
+          if (compTraces.some((trace) => trace.suppressNetLabel)) continue
+
           // Choose a representative trace (longest by L1 length)
           const lengthOf = (path: SolvedTracePath) => {
             let sum = 0

package/lib/types/InputProblem.ts

@@ -43,7 +43,9 @@ export 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
 
@@ -67,9 +69,10 @@ export interface InputNetConnection {
   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
 

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.143",
+  "version": "0.0.145",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/assets/inline-net-label-two-pin-net.json

@@ -0,0 +1,67 @@
+{
+  "chips": [
+    {
+      "chipId": "U1",
+      "center": { "x": -1, "y": 1 },
+      "width": 1,
+      "height": 1,
+      "sectionId": "routed",
+      "pins": [
+        { "pinId": "U1.1", "x": -0.5, "y": 1, "_facingDirection": "x+" }
+      ]
+    },
+    {
+      "chipId": "U2",
+      "center": { "x": 1, "y": 1 },
+      "width": 1,
+      "height": 1,
+      "sectionId": "routed",
+      "pins": [
+        { "pinId": "U2.1", "x": 0.5, "y": 1, "_facingDirection": "x-" }
+      ]
+    },
+    {
+      "chipId": "U3",
+      "center": { "x": -2, "y": -1 },
+      "width": 1,
+      "height": 1,
+      "sectionId": "left",
+      "pins": [
+        { "pinId": "U3.1", "x": -1.5, "y": -1, "_facingDirection": "x+" }
+      ]
+    },
+    {
+      "chipId": "U4",
+      "center": { "x": 2, "y": -1 },
+      "width": 1,
+      "height": 1,
+      "sectionId": "right",
+      "pins": [
+        { "pinId": "U4.1", "x": 1.5, "y": -1, "_facingDirection": "x-" }
+      ]
+    }
+  ],
+  "directConnections": [],
+  "netConnections": [
+    {
+      "netId": "NET_ROUTED",
+      "pinIds": ["U1.1", "U2.1"],
+      "netLabelWidth": 0.9,
+      "allowInlineNetLabel": true,
+      "inlineNetLabelWidth": 0.9,
+      "inlineNetLabelHeight": 0.12
+    },
+    {
+      "netId": "NET_SECTIONED",
+      "pinIds": ["U3.1", "U4.1"],
+      "netLabelWidth": 1.1,
+      "allowInlineNetLabel": true,
+      "inlineNetLabelWidth": 1.1,
+      "inlineNetLabelHeight": 0.12
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "NET_ROUTED": ["x-", "x+"],
+    "NET_SECTIONED": ["x-", "x+"]
+  }
+}