@tscircuit/schematic-trace-solver 0.0.140 → 0.0.142

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,
       })

package/lib/solvers/InlineNetLabelSolver/alignPortOnlyInlineNetLabelStubs.ts

@@ -0,0 +1,233 @@
+import type { Bounds, Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
+
+type StubDirection = "x+" | "x-" | "y+" | "y-"
+
+const getStubDirection = (path: [Point, Point]): StubDirection | undefined => {
+  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-"
+}
+
+const getStubLength = (path: [Point, Point]) => {
+  const [start, end] = path
+  return Math.abs(end.x - start.x) + Math.abs(end.y - start.y)
+}
+
+const getLabelBounds = (placement: {
+  center: Point
+  width: number
+  height: number
+  axis?: "x" | "y"
+}): Bounds => {
+  const isVertical = placement.axis === "y"
+  const width = isVertical ? placement.height : placement.width
+  const height = isVertical ? 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,
+  }
+}
+
+const getPathBounds = (path: Point[]): Bounds => ({
+  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)),
+})
+
+const doesPathIntersectBounds = (path: Point[], bounds: Bounds): boolean => {
+  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
+}
+
+const resizeStub = (
+  placement: InlineNetLabelPlacement,
+  direction: StubDirection,
+  targetLength: number,
+): InlineNetLabelPlacement => {
+  const [start] = placement.stubTracePath!
+  const end: Point =
+    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,
+  }
+}
+
+/**
+ * Aligns the free ends of port-only inline-label stubs on each component side.
+ *
+ * A group is changed atomically: if any longer stub or retained label would
+ * collide with a chip, component text, routed trace, retained anchored label,
+ * or another inline label/stub, every member keeps its original length.
+ */
+export const alignPortOnlyInlineNetLabelStubs = ({
+  placements,
+  inputProblem,
+  traces,
+  netLabelPlacements,
+}: {
+  placements: InlineNetLabelPlacement[]
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}): InlineNetLabelPlacement[] => {
+  const chipIdByPinId = new Map<string, string>()
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) chipIdByPinId.set(pin.pinId, chip.chipId)
+  }
+
+  const groups = new Map<
+    string,
+    Array<{
+      placementIndex: number
+      placement: InlineNetLabelPlacement
+      direction: StubDirection
+      ownerChipId?: string
+    }>
+  >()
+  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(getLabelBounds)
+
+  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 = getLabelBounds(proposal)
+      const stubPath = proposal.stubTracePath!
+      const stubBounds = getPathBounds(stubPath)
+      const ownerChipId = group[proposalIndex]!.ownerChipId
+
+      for (const chip of inputProblem.chips) {
+        const chipBounds: Bounds = {
+          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 = getLabelBounds(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 = getLabelBounds(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
+}

package/lib/solvers/TraceOverlapShiftSolver/TraceOverlapShiftSolver.ts

@@ -11,6 +11,9 @@ import {
 import type { MspConnectionPairId } from "../MspConnectionPairSolver/MspConnectionPairSolver"
 
 type ConnNetId = string
+type TraceState = Record<MspConnectionPairId, SolvedTracePath>
+
+const TRACE_STATE_POSITION_EPSILON = 1e-6
 
 /**
  * This solver finds traces that overlap or meet collinearly and aren't
@@ -44,6 +47,9 @@ export class TraceOverlapShiftSolver extends BaseSolver {
   traceNetIslands: Record<ConnNetId, Array<SolvedTracePath>> = {}
 
   correctedTraceMap: Record<MspConnectionPairId, SolvedTracePath> = {}
+  // Keep only the current and previous layouts to detect a two-state cycle
+  // without accumulating routing history for the whole solve.
+  recentTraceStates: TraceState[] = []
 
   cleanupPhase: "diagonals" | "done" | null = null
 
@@ -64,6 +70,8 @@ export class TraceOverlapShiftSolver extends BaseSolver {
       this.correctedTraceMap[mspPairId] = tracePath
     }
 
+    this.rememberTraceState(this.correctedTraceMap)
+
     this.traceNetIslands = this.computeTraceNetIslands()
   }
 
@@ -361,11 +369,19 @@ export class TraceOverlapShiftSolver extends BaseSolver {
 
   override _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,
       }
+      // Returning to the older retained layout means corrections are bouncing
+      // A -> B -> A. Keep B and finish this pass instead of retrying forever.
+      if (this.returnsToPreviousTraceState(nextTraceState)) {
+        this.activeSubSolver = null
+        this.solved = true
+        return
+      }
+      this.correctedTraceMap = nextTraceState
+      this.rememberTraceState(nextTraceState)
       this.activeSubSolver = null
       this.traceNetIslands = this.computeTraceNetIslands()
     }
@@ -407,6 +423,46 @@ export class TraceOverlapShiftSolver extends BaseSolver {
     })
   }
 
+  private rememberTraceState(traceState: TraceState) {
+    this.recentTraceStates.push({ ...traceState })
+    if (this.recentTraceStates.length > 2) {
+      this.recentTraceStates.shift()
+    }
+  }
+
+  private returnsToPreviousTraceState(candidateTraceState: TraceState) {
+    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
+
+    // Corrections create new objects, so compare the trace geometry itself.
+    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
+  }
+
   override visualize() {
     if (this.activeSubSolver) {
       return this.activeSubSolver.visualize()

package/lib/types/InputProblem.ts

@@ -65,6 +65,19 @@ export 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
 }
 
 export interface InputProblem {

package/package.json

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