@tscircuit/schematic-trace-solver 0.0.186 → 0.0.188

package/lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts

@@ -76,33 +76,52 @@ const getRequiredOutwardDistance = (
   label: NetLabelPlacement,
   inlineBounds: Bounds[],
 ) => {
-  const labelBounds = getAnchoredNetLabelRenderedBounds(label)
-
-  if (label.orientation === "x-" || label.orientation === "x+") {
-    const nearby = inlineBounds.filter(
-      (bounds) =>
-        labelBounds.minY < bounds.maxY && labelBounds.maxY > bounds.minY,
+  let distance = 0
+  // Only clear obstacles within the current proposal's clearance. A label elsewhere
+  // on the same row must not force this label across the whole schematic.
+  // Moving past one obstacle can encounter another, so continue until clear.
+  for (let iteration = 0; iteration < inlineBounds.length; iteration++) {
+    const labelBounds = getAnchoredNetLabelRenderedBounds(
+      moveLabel(label, label.orientation, distance),
+    )
+    const horizontal = label.orientation === "x-" || label.orientation === "x+"
+    const overlapping = inlineBounds.filter((bounds) =>
+      boundsOverlap(labelBounds, {
+        minX: bounds.minX - (horizontal ? LABEL_CLEARANCE : 0),
+        maxX: bounds.maxX + (horizontal ? LABEL_CLEARANCE : 0),
+        minY: bounds.minY - (horizontal ? 0 : LABEL_CLEARANCE),
+        maxY: bounds.maxY + (horizontal ? 0 : LABEL_CLEARANCE),
+      }),
     )
-    if (nearby.length === 0) return 0
-    if (label.orientation === "x-") {
-      const targetMaxX = Math.min(...nearby.map((bounds) => bounds.minX))
-      return Math.max(0, labelBounds.maxX - targetMaxX + LABEL_CLEARANCE)
+    if (overlapping.length === 0) break
+    switch (label.orientation) {
+      case "x-":
+        distance +=
+          labelBounds.maxX -
+          Math.min(...overlapping.map((b) => b.minX)) +
+          LABEL_CLEARANCE
+        break
+      case "x+":
+        distance +=
+          Math.max(...overlapping.map((b) => b.maxX)) -
+          labelBounds.minX +
+          LABEL_CLEARANCE
+        break
+      case "y-":
+        distance +=
+          labelBounds.maxY -
+          Math.min(...overlapping.map((b) => b.minY)) +
+          LABEL_CLEARANCE
+        break
+      case "y+":
+        distance +=
+          Math.max(...overlapping.map((b) => b.maxY)) -
+          labelBounds.minY +
+          LABEL_CLEARANCE
+        break
     }
-    const targetMinX = Math.max(...nearby.map((bounds) => bounds.maxX))
-    return Math.max(0, targetMinX - labelBounds.minX + LABEL_CLEARANCE)
   }
-
-  const nearby = inlineBounds.filter(
-    (bounds) =>
-      labelBounds.minX < bounds.maxX && labelBounds.maxX > bounds.minX,
-  )
-  if (nearby.length === 0) return 0
-  if (label.orientation === "y-") {
-    const targetMaxY = Math.min(...nearby.map((bounds) => bounds.minY))
-    return Math.max(0, labelBounds.maxY - targetMaxY + LABEL_CLEARANCE)
-  }
-  const targetMinY = Math.max(...nearby.map((bounds) => bounds.maxY))
-  return Math.max(0, targetMinY - labelBounds.minY + LABEL_CLEARANCE)
+  return distance
 }
 
 const moveLabel = (
@@ -159,17 +178,14 @@ const sharesOwnerChip = (
 ) =>
   label.pinIds.some((pinId) => ownerChipIds.has(chipIdByPinId.get(pinId) ?? ""))
 
-const isGeneratedLabelConnector = (trace: SolvedTracePath) =>
-  trace.mspPairId.startsWith("available-net-orientation-") ||
-  trace.mspPairId.startsWith("inline-net-label-clearance-")
-
 const findConnectorTraceIndex = (
   label: NetLabelPlacement,
   traces: SolvedTracePath[],
+  connectorTraceIds: ReadonlySet<string>,
 ) =>
   traces.findIndex((trace) => {
     if (trace.globalConnNetId !== label.globalConnNetId) return false
-    if (!isGeneratedLabelConnector(trace)) return false
+    if (!connectorTraceIds.has(trace.mspPairId)) return false
     const first = trace.tracePath[0]
     const last = trace.tracePath.at(-1)
     return Boolean(
@@ -298,7 +314,9 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
   traces,
   netLabelPlacements,
   inlineNetLabelPlacements,
+  netLabelConnectorTraceIds = new Set<string>(),
 }: {
+  netLabelConnectorTraceIds?: ReadonlySet<string>
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
@@ -307,7 +325,9 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
   movedLabelCount: number
+  netLabelConnectorTraceIds: ReadonlySet<string>
 } => {
+  const connectorTraceIds = new Set(netLabelConnectorTraceIds)
   const outputTraces = traces.map((trace) => ({
     ...trace,
     tracePath: trace.tracePath.map((point) => ({ ...point })),
@@ -364,7 +384,11 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
           if (!boundsOverlap(movingBounds, obstacleBounds)) continue
           if (
             !sharesOwnerChip(obstacle, ownerChipIds, chipIdByPinId) ||
-            (findConnectorTraceIndex(obstacle, outputTraces) === -1 &&
+            (findConnectorTraceIndex(
+              obstacle,
+              outputTraces,
+              connectorTraceIds,
+            ) === -1 &&
               !canAddConnectorAtAnchor(obstacle, outputTraces, pinMap))
           ) {
             failed = true
@@ -460,7 +484,11 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
     }> = []
     for (const [labelIndex, movedLabel] of proposals) {
       const label = outputLabels[labelIndex]!
-      const connectorIndex = findConnectorTraceIndex(label, outputTraces)
+      const connectorIndex = findConnectorTraceIndex(
+        label,
+        outputTraces,
+        connectorTraceIds,
+      )
       if (
         connectorIndex === -1 &&
         !canAddConnectorAtAnchor(label, outputTraces, pinMap)
@@ -528,6 +556,7 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
       movedLabelIndices.add(labelIndex)
     }
     for (const update of connectorUpdates) {
+      connectorTraceIds.add(update.trace.mspPairId)
       if (update.connectorIndex === -1) outputTraces.push(update.trace)
       else outputTraces[update.connectorIndex] = update.trace
     }
@@ -537,5 +566,6 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
     traces: outputTraces,
     netLabelPlacements: outputLabels,
     movedLabelCount: movedLabelIndices.size,
+    netLabelConnectorTraceIds: connectorTraceIds,
   }
 }

package/lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts

@@ -1,3 +1,4 @@
+import { getAnchoredNetLabelRenderedBounds } from "../InlineNetLabelSolver/getAnchoredNetLabelRenderedBounds"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
@@ -91,6 +92,10 @@ function sampleAnchorsAlongSegment(
 }
 
 export interface NetLabelNetLabelCollisionSolverParams {
+  /** Use the final horizontal tag envelope after inline conversion. */
+  useRenderedLabelBounds?: boolean
+  /** Already placed labels that are obstacles, but must not be moved. */
+  fixedNetLabelPlacements?: NetLabelPlacement[]
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
@@ -107,7 +112,7 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
   currentLabelToMove: NetLabelPlacement | null = null
   candidateResults: Candidate[] = []
 
-  private chipIndex: ChipObstacleSpatialIndex
+  private chipIndex: ChipObstacleSpatialIndex | undefined
   private traceMap: Record<MspConnectionPairId, SolvedTracePath>
   private skippedCollisionKeys = new Set<string>()
 
@@ -115,7 +120,7 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
   private candidateQueue: Candidate[] = []
   private candidateIndex = 0
 
-  constructor(params: NetLabelNetLabelCollisionSolverParams) {
+  constructor(private params: NetLabelNetLabelCollisionSolverParams) {
     super()
     this.inputProblem = params.inputProblem
     this.traces = params.traces
@@ -123,7 +128,9 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
     this.outputNetLabelPlacements = [...params.netLabelPlacements]
     this.chipIndex =
       params.inputProblem._chipObstacleSpatialIndex ??
-      new ChipObstacleSpatialIndex(params.inputProblem.chips)
+      (params.inputProblem.chips.length > 0
+        ? new ChipObstacleSpatialIndex(params.inputProblem.chips)
+        : undefined)
     this.traceMap = Object.fromEntries(
       params.traces.map((t) => [t.mspPairId, t]),
     ) as Record<MspConnectionPairId, SolvedTracePath>
@@ -136,6 +143,8 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
       inputProblem: this.inputProblem,
       traces: this.traces,
       netLabelPlacements: this.netLabelPlacements,
+      fixedNetLabelPlacements: this.params.fixedNetLabelPlacements,
+      useRenderedLabelBounds: this.params.useRenderedLabelBounds,
     }
   }
 
@@ -144,7 +153,12 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
   }
 
   private labelBounds(label: NetLabelPlacement) {
-    return getRectBounds(label.center, label.width, label.height)
+    if (
+      !this.params.useRenderedLabelBounds ||
+      this.params.fixedNetLabelPlacements?.includes(label)
+    )
+      return getRectBounds(label.center, label.width, label.height)
+    return getAnchoredNetLabelRenderedBounds(label)
   }
 
   private collisionKey(a: NetLabelPlacement, b: NetLabelPlacement) {
@@ -154,12 +168,19 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
   private findNextCollidingPair():
     | [NetLabelPlacement, NetLabelPlacement]
     | null {
-    const labels = this.outputNetLabelPlacements
-    for (let i = 0; i < labels.length; i++) {
+    const labels = [
+      ...this.outputNetLabelPlacements,
+      ...(this.params.fixedNetLabelPlacements ?? []),
+    ]
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       for (let j = i + 1; j < labels.length; j++) {
         const a = labels[i]!
         const b = labels[j]!
-        if (a.globalConnNetId === b.globalConnNetId) continue
+        if (
+          a.globalConnNetId === b.globalConnNetId &&
+          !this.params.fixedNetLabelPlacements?.includes(b)
+        )
+          continue
         if (this.skippedCollisionKeys.has(this.collisionKey(a, b))) continue
         if (boundsOverlap(this.labelBounds(a), this.labelBounds(b)))
           return [a, b]
@@ -208,7 +229,16 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
         center,
         width,
         height,
-        bounds: getRectBounds(center, width, height),
+        bounds: this.params.useRenderedLabelBounds
+          ? getAnchoredNetLabelRenderedBounds({
+              ...label,
+              orientation,
+              anchorPoint: anchor,
+              center,
+              width,
+              height,
+            })
+          : getRectBounds(center, width, height),
         hostPairId,
         hostSegIndex,
         status: null,
@@ -271,7 +301,7 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
   ): CandidateStatus {
     const { bounds, hostPairId, hostSegIndex } = candidate
 
-    if (this.chipIndex.getChipsInBounds(bounds).length > 0)
+    if ((this.chipIndex?.getChipsInBounds(bounds).length ?? 0) > 0)
       return "chip-collision"
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
       return "text-collision"
@@ -284,7 +314,11 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
     }
 
     for (const obstacle of obstacleLabels) {
-      if (obstacle.globalConnNetId === movingLabelNetId) continue
+      if (
+        obstacle.globalConnNetId === movingLabelNetId &&
+        !this.params.fixedNetLabelPlacements?.includes(obstacle)
+      )
+        continue
       if (boundsOverlap(bounds, this.labelBounds(obstacle)))
         return "label-collision"
     }
@@ -299,6 +333,38 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
     this.candidateResults = []
   }
 
+  /** Reuse the normal anchor search for a local trace-clearance proposal. */
+  getNearbyValidPlacements(
+    label: NetLabelPlacement,
+    maxDistance: number,
+  ): NetLabelPlacement[] {
+    const distance = (candidate: Candidate) =>
+      Math.hypot(
+        candidate.anchor.x - label.anchorPoint.x,
+        candidate.anchor.y - label.anchorPoint.y,
+      )
+    const obstacles = [
+      ...this.outputNetLabelPlacements.filter((other) => other !== label),
+      ...(this.params.fixedNetLabelPlacements ?? []),
+    ]
+    return this.buildCandidatesForLabel(label)
+      .filter(
+        (candidate) =>
+          distance(candidate) <= maxDistance &&
+          this.checkCandidate(candidate, label.globalConnNetId, obstacles) ===
+            "ok",
+      )
+      .sort((a, b) => distance(a) - distance(b))
+      .map((candidate) => ({
+        ...label,
+        orientation: candidate.orientation,
+        anchorPoint: candidate.anchor,
+        center: candidate.center,
+        width: candidate.width,
+        height: candidate.height,
+      }))
+  }
+
   private clearActiveSearch() {
     this.currentCollision = null
     this.currentLabelToMove = null
@@ -316,7 +382,9 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
         return
       }
       this.currentCollision = pair
-      this.labelsToTry = [pair[1], pair[0]]
+      this.labelsToTry = [pair[1], pair[0]].filter(
+        (label) => !(this.params.fixedNetLabelPlacements ?? []).includes(label),
+      )
       this.beginSearchForLabel(this.labelsToTry.shift()!)
       return
     }
@@ -342,9 +410,10 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
       fixedLabel = labelB
     }
     const obstacleLabels = [
-      ...this.outputNetLabelPlacements.filter(
-        (l) => l !== labelA && l !== labelB,
-      ),
+      ...[
+        ...this.outputNetLabelPlacements,
+        ...(this.params.fixedNetLabelPlacements ?? []),
+      ].filter((l) => l !== labelA && l !== labelB),
       fixedLabel,
     ]
 

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -44,7 +44,6 @@ interface CandidatePair {
   netConnectionPinIds?: PinId[]
 }
 
-const AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-"
 const RECOVERED_TRACE_PREFIX = "net-label-to-trace-"
 const MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET = 0.05
 const MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25
@@ -82,6 +81,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
   outputTraces: SolvedTracePath[]
   outputNetLabelPlacements: NetLabelPlacement[]
 
+  private readonly recoveredTraceIds = new Set<string>()
   private chipMap: Record<ChipId, InputChip>
   private pinMap: Map<PinId, TraceRecoveryPin>
   private queuedCandidates: CandidatePair[]
@@ -424,7 +424,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
     trace: SolvedTracePath,
     candidate: CandidatePair,
   ) {
-    if (!trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_PREFIX)) {
+    if (!this.input.netLabelConnectorTraceIds?.has(trace.mspPairId)) {
       return false
     }
     if (trace.pinIds.length !== 1) return false
@@ -491,6 +491,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
       pinIds: [firstPin.pinId, secondPin.pinId],
     }
 
+    this.recoveredTraceIds.add(mspPairId)
     this.outputTraces = [...retainedTraces, recoveredTrace]
     if (candidate.recoveryMode !== "routed_components") {
       this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
@@ -566,7 +567,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
       ...this.getOutput(),
     })
     for (const trace of this.outputTraces) {
-      if (!trace.mspPairId.startsWith(RECOVERED_TRACE_PREFIX)) continue
+      if (!this.recoveredTraceIds.has(trace.mspPairId)) continue
       graphics.lines!.push({
         points: trace.tracePath,
         strokeColor: "green",

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -648,20 +648,18 @@ const pathsIntersect = (firstPath: Point[], secondPath: Point[]) => {
 }
 
 /**
- * Keep generated label connectors joined when their host trace moves. Only a
+ * Keep same-net branches joined when their host trace moves. Only a
  * connector endpoint is projected, and only along its existing first/last
  * segment, so the label and the rest of its route stay fixed.
  */
-const preserveAttachedLabelConnectorJunctions = ({
+const preserveAttachedTraceJunctions = ({
   originalTrace,
   candidateTrace,
   traces,
-  netLabelConnectorTraceIds,
 }: {
   originalTrace: SolvedTracePath
   candidateTrace: SolvedTracePath
   traces: SolvedTracePath[]
-  netLabelConnectorTraceIds: ReadonlySet<MspConnectionPairId>
 }): SolvedTracePath[] | null => {
   let outputTraces = traces.map((trace) =>
     trace.mspPairId === originalTrace.mspPairId ? candidateTrace : trace,
@@ -670,7 +668,6 @@ const preserveAttachedLabelConnectorJunctions = ({
   for (const connector of traces) {
     if (
       connector.mspPairId === originalTrace.mspPairId ||
-      !netLabelConnectorTraceIds.has(connector.mspPairId) ||
       connector.globalConnNetId !== originalTrace.globalConnNetId ||
       !pathsIntersect(originalTrace.tracePath, connector.tracePath) ||
       pathsIntersect(candidateTrace.tracePath, connector.tracePath)
@@ -686,6 +683,16 @@ const preserveAttachedLabelConnectorJunctions = ({
     )
     if (endpointIndex === undefined) return null
     const originalJunction = connector.tracePath[endpointIndex]!
+    // Component pins are fixed; reject a rail move that would detach one.
+    if (
+      connector.pins.some(
+        (pin) =>
+          nearlyEqual(pin.x, originalJunction.x) &&
+          nearlyEqual(pin.y, originalJunction.y),
+      )
+    ) {
+      return null
+    }
     const movedJunction = getMovedAnchorPointForReroute(
       originalJunction,
       originalTrace.tracePath,
@@ -1250,11 +1257,10 @@ export const alignSameNetJunctions = ({
             netLabelPlacements: outputNetLabelPlacements,
             attachedLabelIndexes,
           })
-          const candidateTraces = preserveAttachedLabelConnectorJunctions({
+          const candidateTraces = preserveAttachedTraceJunctions({
             originalTrace: branchTrace,
             candidateTrace,
             traces: outputTraces,
-            netLabelConnectorTraceIds,
           })
           if (!candidateTraces) continue
           if (
@@ -1272,10 +1278,7 @@ export const alignSameNetJunctions = ({
           }
 
           const movedConnectorsAreClear = candidateTraces.every((trace) => {
-            if (
-              trace.mspPairId === branchTrace.mspPairId ||
-              !netLabelConnectorTraceIds.has(trace.mspPairId)
-            ) {
+            if (trace.mspPairId === branchTrace.mspPairId) {
               return true
             }
             const originalConnector = outputTraces.find(

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -598,6 +598,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
             traces: junctionOutput.traces,
             netLabelPlacements: junctionOutput.netLabelPlacements,
             completedReroutes,
+            resolveTraceCollisions: true,
+            netLabelConnectorTraceIds:
+              instance.availableNetOrientationSolver!.netLabelConnectorTraceIds,
           },
         ]
       },

package/lib/types/InputProblem.ts

@@ -120,8 +120,8 @@ export interface InputNetConnection {
    * When true, a named net may use inline labels. Each routed connected
    * component gets a label along its representative trace, while each
    * disconnected endpoint gets an outward inline-label stub. Conversion is
-   * atomic for the whole net so inline and anchored representations are not
-   * mixed when any label cannot be placed.
+   * atomic within each routed component. An obstructed component retains its
+   * anchored label without preventing inline labels on disconnected components.
    */
   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.186",
+  "version": "0.0.188",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/bug-reports/bug-report-20260907T083336Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260907T083336Z/bug-report-20260907T083336Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/bug-reports/bug-report-20260907T110144Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260907T110144Z/bug-report-20260907T110144Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/bug-reports/bug-report-20260907T145640Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260907T145640Z/bug-report-20260907T145640Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />