@tscircuit/schematic-trace-solver 0.0.149 → 0.0.151

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -0,0 +1,338 @@
+import {
+  doesSegmentIntersectRect,
+  getBoundFromCenteredRect,
+  type Point,
+} from "@tscircuit/math-utils"
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import { doesPairCrossRestrictedCenterLines } from "lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import {
+  getTraceRecoveryConnectivityMaps,
+  type TraceRecoveryPin,
+} from "lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+import type {
+  ChipId,
+  InputChip,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import { arePinsInDifferentSchematicSections } from "lib/utils/arePinsInDifferentSchematicSections"
+import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap-with-existing-traces"
+import {
+  type InlineNetLabelPlacement,
+  type InlineNetLabelOutput,
+  visualizeInlineNetLabelOutput,
+} from "../InlineNetLabelSolver/InlineNetLabelSolver"
+
+type GlobalConnNetId = NetLabelPlacement["globalConnNetId"]
+
+interface CandidatePair {
+  firstLabel: NetLabelPlacement
+  secondLabel: NetLabelPlacement
+  pins: [TraceRecoveryPin, TraceRecoveryPin]
+  perpendicularOffset: number
+  routeDistance: number
+  key: string
+}
+
+const AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-"
+const RECOVERED_TRACE_PREFIX = "net-label-to-trace-"
+
+const getCanonicalPairKey = (firstPinId: PinId, secondPinId: PinId) =>
+  [firstPinId, secondPinId].sort().join("--")
+
+export const pathIntersectsRenderedLabel = (
+  path: Point[],
+  label: NetLabelPlacement | InlineNetLabelPlacement,
+) => {
+  let width = label.width
+  let height = label.height
+  if ("axis" in label && label.axis === "y") {
+    width = label.height
+    height = label.width
+  }
+  const bounds = getBoundFromCenteredRect({
+    center: label.center,
+    width,
+    height,
+  })
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    if (
+      doesSegmentIntersectRect(path[pathIndex]!, path[pathIndex + 1]!, bounds)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+const getPerpendicularOffset = (
+  firstPin: TraceRecoveryPin,
+  secondPin: TraceRecoveryPin,
+) => {
+  const xDistance = Math.abs(firstPin.x - secondPin.x)
+  const yDistance = Math.abs(firstPin.y - secondPin.y)
+  if (xDistance >= yDistance) return yDistance
+  return xDistance
+}
+
+export class NetLabelToTraceSolver extends BaseSolver {
+  inputProblem: InputProblem
+
+  outputTraces: SolvedTracePath[]
+  outputNetLabelPlacements: NetLabelPlacement[]
+
+  private chipMap: Record<ChipId, InputChip>
+  private pinMap: Map<PinId, TraceRecoveryPin>
+  private queuedCandidates: CandidatePair[]
+  private currentCandidate: CandidatePair | null = null
+  declare activeSubSolver: SchematicTraceSingleLineSolver2 | null
+
+  constructor(private input: InlineNetLabelOutput) {
+    super()
+    this.inputProblem = input.inputProblem
+    this.outputTraces = [...input.traces]
+    this.outputNetLabelPlacements = [...input.netLabelPlacements]
+
+    const { chipMap, pinMap } = getTraceRecoveryConnectivityMaps(
+      this.inputProblem,
+    )
+    this.chipMap = chipMap
+    this.pinMap = pinMap
+
+    this.queuedCandidates = this.buildCandidatePairs()
+    this.stats.candidateCount = this.queuedCandidates.length
+    this.stats.recoveredTraceCount = 0
+  }
+
+  override getConstructorParams(): [InlineNetLabelOutput] {
+    return [this.input]
+  }
+
+  private isEligiblePortOnlyDirectConnectionLabel(
+    label: NetLabelPlacement,
+    groundGlobalConnNetId?: GlobalConnNetId,
+  ) {
+    if (
+      label.pinIds.length !== 1 ||
+      label.mspConnectionPairIds.length !== 0 ||
+      !label.netId ||
+      label.netId === "GND" ||
+      label.globalConnNetId === groundGlobalConnNetId
+    ) {
+      return false
+    }
+
+    const pinId = label.pinIds[0]!
+    return this.inputProblem.directConnections.some(
+      (connection) =>
+        connection.netId === label.netId && connection.pinIds.includes(pinId),
+    )
+  }
+
+  private buildCandidatePairs() {
+    const { netConnMap } = getConnectivityMapsFromInputProblem(
+      this.inputProblem,
+    )
+    const groundGlobalConnNetId =
+      netConnMap.getNetConnectedToId("GND") ?? undefined
+    const labelsByGlobalNet = new Map<GlobalConnNetId, NetLabelPlacement[]>()
+
+    for (const label of this.input.netLabelPlacements) {
+      if (
+        !this.isEligiblePortOnlyDirectConnectionLabel(
+          label,
+          groundGlobalConnNetId,
+        )
+      ) {
+        continue
+      }
+      const labels = labelsByGlobalNet.get(label.globalConnNetId) ?? []
+      labels.push(label)
+      labelsByGlobalNet.set(label.globalConnNetId, labels)
+    }
+
+    const candidates: CandidatePair[] = []
+    for (const labels of labelsByGlobalNet.values()) {
+      for (let firstIndex = 0; firstIndex < labels.length; firstIndex++) {
+        for (
+          let secondIndex = firstIndex + 1;
+          secondIndex < labels.length;
+          secondIndex++
+        ) {
+          const firstLabel = labels[firstIndex]!
+          const secondLabel = labels[secondIndex]!
+          const firstPin = this.pinMap.get(firstLabel.pinIds[0]!)
+          const secondPin = this.pinMap.get(secondLabel.pinIds[0]!)
+          if (!firstPin || !secondPin) continue
+          if (
+            arePinsInDifferentSchematicSections(
+              this.inputProblem,
+              firstPin,
+              secondPin,
+            )
+          ) {
+            continue
+          }
+          if (
+            doesPairCrossRestrictedCenterLines({
+              inputProblem: this.inputProblem,
+              chipMap: this.chipMap,
+              pinIdMap: this.pinMap,
+              p1: firstPin,
+              p2: secondPin,
+            })
+          ) {
+            continue
+          }
+
+          candidates.push({
+            firstLabel,
+            secondLabel,
+            pins: [firstPin, secondPin],
+            perpendicularOffset: getPerpendicularOffset(firstPin, secondPin),
+            routeDistance:
+              Math.abs(firstPin.x - secondPin.x) +
+              Math.abs(firstPin.y - secondPin.y),
+            key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
+          })
+        }
+      }
+    }
+
+    candidates.sort(
+      (first, second) =>
+        first.perpendicularOffset - second.perpendicularOffset ||
+        first.routeDistance - second.routeDistance ||
+        first.key.localeCompare(second.key),
+    )
+    return candidates
+  }
+
+  private isSupersededConnectorTrace(
+    trace: SolvedTracePath,
+    candidate: CandidatePair,
+  ) {
+    if (!trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_PREFIX)) {
+      return false
+    }
+    if (trace.pinIds.length !== 1) return false
+    return candidate.pins.some((pin) => pin.pinId === trace.pinIds[0])
+  }
+
+  private routeIntersectsRemainingLabels(
+    tracePath: Point[],
+    candidate: CandidatePair,
+  ) {
+    for (const label of this.outputNetLabelPlacements) {
+      if (label === candidate.firstLabel || label === candidate.secondLabel) {
+        continue
+      }
+      if (pathIntersectsRenderedLabel(tracePath, label)) return true
+    }
+    return this.input.inlineNetLabelPlacements.some((label) =>
+      pathIntersectsRenderedLabel(tracePath, label),
+    )
+  }
+
+  private tryAcceptCurrentRoute() {
+    const candidate = this.currentCandidate
+    const tracePath = this.activeSubSolver?.solvedTracePath
+    if (!candidate || !tracePath) return
+
+    const retainedTraces = this.outputTraces.filter(
+      (trace) => !this.isSupersededConnectorTrace(trace, candidate),
+    )
+    if (
+      doesTraceOverlapWithExistingTraces(tracePath, retainedTraces) ||
+      this.routeIntersectsRemainingLabels(tracePath, candidate)
+    ) {
+      return
+    }
+
+    const [firstPin, secondPin] = candidate.pins
+    const mspPairId = `${RECOVERED_TRACE_PREFIX}${candidate.key}`
+    const recoveredTrace: SolvedTracePath = {
+      mspPairId,
+      dcConnNetId: candidate.firstLabel.globalConnNetId,
+      globalConnNetId: candidate.firstLabel.globalConnNetId,
+      pins: [firstPin, secondPin],
+      tracePath,
+      mspConnectionPairIds: [mspPairId],
+      pinIds: [firstPin.pinId, secondPin.pinId],
+    }
+
+    this.outputTraces = [...retainedTraces, recoveredTrace]
+    this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
+      (label) =>
+        label !== candidate.firstLabel && label !== candidate.secondLabel,
+    )
+    this.stats.recoveredTraceCount++
+  }
+
+  override _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+      if (this.activeSubSolver.solved) {
+        this.tryAcceptCurrentRoute()
+        this.activeSubSolver = null
+        this.currentCandidate = null
+      } else if (this.activeSubSolver.failed) {
+        this.activeSubSolver = null
+        this.currentCandidate = null
+      }
+      return
+    }
+
+    let candidate = this.queuedCandidates.shift()
+    while (
+      candidate &&
+      (!this.outputNetLabelPlacements.includes(candidate.firstLabel) ||
+        !this.outputNetLabelPlacements.includes(candidate.secondLabel))
+    ) {
+      candidate = this.queuedCandidates.shift()
+    }
+
+    if (!candidate) {
+      this.solved = true
+      return
+    }
+
+    this.currentCandidate = candidate
+    this.activeSubSolver = new SchematicTraceSingleLineSolver2({
+      inputProblem: this.inputProblem,
+      pins: candidate.pins,
+      chipMap: this.chipMap,
+    })
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements,
+      inlineNetLabelPlacements: this.input.inlineNetLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.activeSubSolver) return this.activeSubSolver.visualize()
+
+    const graphics = visualizeInlineNetLabelOutput({
+      inputProblem: this.inputProblem,
+      ...this.getOutput(),
+    })
+    for (const trace of this.outputTraces) {
+      if (!trace.mspPairId.startsWith(RECOVERED_TRACE_PREFIX)) continue
+      graphics.lines!.push({
+        points: trace.tracePath,
+        strokeColor: "green",
+        label: `recovered from net labels: ${trace.pinIds.join(" -> ")}`,
+      })
+    }
+    return graphics
+  }
+}

package/lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps.ts

@@ -0,0 +1,33 @@
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type {
+  ChipId,
+  InputChip,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+
+export type TraceRecoveryPin = MspConnectionPair["pins"][number] & {
+  _facingDirection: FacingDirection
+}
+
+export const getTraceRecoveryConnectivityMaps = (
+  inputProblem: InputProblem,
+) => {
+  const chipMap: Record<ChipId, InputChip> = {}
+  const pinMap = new Map<PinId, TraceRecoveryPin>()
+
+  for (const chip of inputProblem.chips) {
+    chipMap[chip.chipId] = chip
+    for (const pin of chip.pins) {
+      pinMap.set(pin.pinId, {
+        ...pin,
+        chipId: chip.chipId,
+        _facingDirection: pin._facingDirection ?? getPinDirection(pin, chip),
+      })
+    }
+  }
+
+  return { chipMap, pinMap }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -35,6 +35,7 @@ import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/Unro
 import { SameNetJunctionAlignmentSolver } from "../SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver"
 import { TraceElbowTransitionSimplificationSolver } from "../TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver"
 import { InlineNetLabelSolver } from "../InlineNetLabelSolver/InlineNetLabelSolver"
+import { NetLabelToTraceSolver } from "../NetLabelToTraceSolver/NetLabelToTraceSolver"
 import { findPerpendicularPathCrossings } from "../TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
@@ -103,6 +104,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   finalTraceElbowTransitionSimplificationSolver?: TraceElbowTransitionSimplificationSolver
   sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver
   inlineNetLabelSolver?: InlineNetLabelSolver
+  netLabelToTraceSolver?: NetLabelToTraceSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -588,6 +590,19 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         ]
       },
     ),
+    definePipelineStep(
+      "netLabelToTraceSolver",
+      NetLabelToTraceSolver,
+      (instance) => {
+        const inlineOutput = instance.inlineNetLabelSolver!.getOutput()
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            ...inlineOutput,
+          },
+        ]
+      },
+    ),
   ]
 
   constructor(inputProblem: InputProblem, opts?: Options) {

package/lib/types/InputProblem.ts

@@ -24,6 +24,15 @@ export interface TextBoxes {
 
 export interface InputChip {
   chipId: ChipId
+
+  /**
+   * Exact directional/oriented schematic-symbol name when the caller has it.
+   * `center`, `width`, and `height` describe the solver obstacle and may be
+   * expanded to include reference/value or manufacturer-part-number text, so
+   * renderers should use this symbol's geometry for the component body.
+   */
+  symbolName?: string
+
   center: { x: number; y: number }
   width: number
   height: number
@@ -33,6 +42,14 @@ export interface InputChip {
 export interface InputDirectConnection {
   pinIds: [PinId, PinId]
   netId?: string
+
+  /**
+   * User-facing text to render for this net label. `netId` remains the stable
+   * connectivity identifier and may be an internal id. When this is omitted
+   * but a label width is provided, renderers should use a width-preserving
+   * placeholder instead of exposing `netId` as label text.
+   */
+  netLabelText?: string
   netLabelWidth?: number
 
   /**
@@ -58,7 +75,8 @@ export interface InputDirectConnection {
 
   /**
    * Extent of the inline net label along the trace. Falls back to
-   * `netLabelWidth`, then to an estimate from the netId text.
+   * `netLabelWidth`, then to an estimate from `netLabelText` (or `netId` for
+   * backwards compatibility).
    */
   inlineNetLabelWidth?: number
 
@@ -72,6 +90,14 @@ export interface InputDirectConnection {
 export interface InputNetConnection {
   netId: string
   pinIds: Array<PinId>
+
+  /**
+   * User-facing text to render for this net label. `netId` remains the stable
+   * connectivity identifier and may be an internal id. When this is omitted
+   * but a label width is provided, renderers should use a width-preserving
+   * placeholder instead of exposing `netId` as label text.
+   */
+  netLabelText?: string
   netLabelWidth?: number
   fallbackNetLabelWidth?: number
   netLabelHeight?: number

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.149",
+  "version": "0.0.151",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -17,10 +17,15 @@
   "devDependencies": {
     "@biomejs/biome": "^2.2.2",
     "@react-hook/resize-observer": "^2.0.2",
+    "@tscircuit/alphabet": "^0.0.26",
+    "@tscircuit/circuit-json-util": "^0.0.111",
     "@tscircuit/math-utils": "^0.0.36",
     "@types/bun": "^1.2.21",
     "bun-match-svg": "^0.0.13",
     "calculate-elbow": "^0.0.12",
+    "circuit-json": "^0.0.475",
+    "circuit-json-to-connectivity-map": "^0.0.29",
+    "circuit-to-svg": "^0.0.407",
     "connectivity-map": "^1.0.0",
     "flatbush": "^4.5.0",
     "graphics-debug": "^0.0.98",
@@ -28,6 +33,8 @@
     "react-cosmos": "^7.0.0",
     "react-cosmos-plugin-vite": "^7.0.0",
     "react-dom": "^19.1.1",
+    "schematic-symbols": "^0.0.241",
+    "stack-svgs": "^0.0.1",
     "tsup": "^8.5.0",
     "vite": "^7.1.3"
   },