@tscircuit/schematic-trace-solver 0.0.141 → 0.0.143

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] ?? []

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -3,9 +3,11 @@ import type { GraphicsObject, Rect } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type {
   InputDirectConnection,
+  InputNetConnection,
   InputProblem,
   PinId,
 } from "lib/types/InputProblem"
@@ -15,6 +17,7 @@ import {
   type AxisAlignedSegment,
   getAxisAlignedSegments,
 } from "./getAxisAlignedSegments"
+import { alignPortOnlyInlineNetLabelStubs } from "./alignPortOnlyInlineNetLabelStubs"
 
 export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
 
@@ -45,9 +48,15 @@ export const INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4
 export 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"
 
@@ -96,7 +105,11 @@ export class InlineNetLabelSolver extends BaseSolver {
   /** 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: Map<string, SolvedTracePath[]>
+  private hasAlignedPortOnlyStubs = false
 
   constructor(input: InlineNetLabelSolverInput) {
     super()
@@ -107,6 +120,9 @@ export class InlineNetLabelSolver 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 = new Map()
     for (const trace of this.traces) {
@@ -132,15 +148,140 @@ export class InlineNetLabelSolver extends BaseSolver {
 
   override _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.
+   */
+  private computePortOnlyInlinePlacement(
+    netConnection: InputNetConnection,
+  ): InlineNetLabelPlacement | null {
+    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)
+
+    // 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.
+    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: Point =
+      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: InlineNetLabelPlacement["axis"] =
+      direction === "x+" || direction === "x-" ? "x" : "y"
+    const side: InlineNetLabelPlacement["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: Point =
+      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: 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,
     }
   }
 
@@ -209,7 +350,13 @@ export class InlineNetLabelSolver extends BaseSolver {
                   maxY: center.y + halfAlong,
                 }
 
-          if (this.isObstructed(bounds, trace)) continue
+          if (
+            this.isObstructed(bounds, {
+              ownTrace: trace,
+              ownGlobalConnNetId: trace.globalConnNetId,
+            })
+          )
+            continue
 
           return {
             globalConnNetId: trace.globalConnNetId,
@@ -334,7 +481,13 @@ export class InlineNetLabelSolver extends BaseSolver {
                 maxY: center.y + halfAlong,
               }
 
-        if (this.isObstructed(bounds, trace)) continue
+        if (
+          this.isObstructed(bounds, {
+            ownTrace: trace,
+            ownGlobalConnNetId: trace.globalConnNetId,
+          })
+        )
+          continue
 
         const anchorPoint: Point =
           axis === "x"
@@ -363,7 +516,16 @@ export class InlineNetLabelSolver extends BaseSolver {
    * An inline label may not sit on top of a chip, a component's text, or a
    * trace belonging to another net.
    */
-  private isObstructed(bounds: Bounds, ownTrace: SolvedTracePath): boolean {
+  private isObstructed(
+    bounds: Bounds,
+    {
+      ownTrace,
+      ownGlobalConnNetId,
+    }: {
+      ownTrace?: SolvedTracePath
+      ownGlobalConnNetId: string
+    },
+  ): boolean {
     for (const chip of this.inputProblem.chips) {
       const chipBounds: Bounds = {
         minX: chip.center.x - chip.width / 2,
@@ -379,8 +541,8 @@ export class InlineNetLabelSolver extends BaseSolver {
     }
 
     for (const trace of this.traces) {
-      if (trace.mspPairId === ownTrace.mspPairId) continue
-      if (trace.globalConnNetId === ownTrace.globalConnNetId) continue
+      if (ownTrace && trace.mspPairId === ownTrace.mspPairId) continue
+      if (trace.globalConnNetId === ownGlobalConnNetId) continue
       if (doesPathIntersectBounds(trace.tracePath, bounds)) return true
     }
 
@@ -399,10 +561,23 @@ export class InlineNetLabelSolver extends BaseSolver {
     return keys
   }
 
+  private getOutputTraces(supersededNetLabelKeys: Set<string>) {
+    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),
       ),
@@ -420,7 +595,8 @@ export class InlineNetLabelSolver extends BaseSolver {
     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",
@@ -446,6 +622,12 @@ export class InlineNetLabelSolver extends BaseSolver {
     }
 
     for (const inlineLabel of this.inlineNetLabelPlacements) {
+      if (inlineLabel.stubTracePath) {
+        graphics.lines.push({
+          points: inlineLabel.stubTracePath,
+          strokeColor: "purple",
+        })
+      }
       const isHorizontal = inlineLabel.axis === "x"
       graphics.rects.push({
         center: inlineLabel.center,
@@ -460,12 +642,29 @@ export class InlineNetLabelSolver extends BaseSolver {
         ].join("\n"),
       } as Rect & { strokeColor: string })
       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 : undefined,
       })