@tscircuit/schematic-trace-solver 0.0.187 → 0.0.189

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,6 +1,8 @@
+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"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { InputProblem } from "lib/types/InputProblem"
@@ -91,6 +93,12 @@ 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[]
+  /** Existing connector identities from AvailableNetOrientationSolver. */
+  netLabelConnectorTraceIds?: ReadonlySet<MspConnectionPairId>
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
@@ -107,7 +115,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 +123,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 +131,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 +146,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 +156,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 +171,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,16 +232,31 @@ 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,
       }
     }
 
-    const isPortOnly = label.mspConnectionPairIds.length === 0
+    // A label on an extended connector must keep that attachment point.
+    const isAnchoredOnConnector = this.traces.some(
+      (trace) =>
+        this.params.netLabelConnectorTraceIds?.has(trace.mspPairId) &&
+        trace.globalConnNetId === label.globalConnNetId &&
+        tracePathContainsPoint(trace.tracePath, label.anchorPoint),
+    )
 
-    if (isPortOnly) {
+    if (label.mspConnectionPairIds.length === 0 || isAnchoredOnConnector) {
       const allOrientations: FacingDirection[] = ["x+", "x-", "y+", "y-"]
       const orderedOrientations = [
         label.orientation,
@@ -271,7 +310,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 +323,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 +342,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 +391,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 +419,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

@@ -8,6 +8,7 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import { getMovedAnchorPointForReroute } from "lib/solvers/Example28Solver/getMovedAnchorPointForReroute"
+import { isLabelAttachedToTrace } from "lib/solvers/Example28Solver/isLabelAttachedToTrace"
 import { moveAttachedLabelsToReroutedTrace } from "lib/solvers/Example28Solver/labelMovement"
 import {
   rectsOverlap,
@@ -182,14 +183,13 @@ const getAttachedLabelIndexes = (
   netLabelPlacements: NetLabelPlacement[],
 ) =>
   netLabelPlacements.flatMap((label, index) => {
-    const labelOwnsTrace =
-      label.mspConnectionPairIds.includes(trace.mspPairId) ||
-      (label.mspConnectionPairIds.length === 0 &&
-        label.globalConnNetId === trace.globalConnNetId)
-    return labelOwnsTrace &&
+    if (
+      isLabelAttachedToTrace(label, trace) &&
       tracePathContainsPoint(trace.tracePath, label.anchorPoint)
-      ? [index]
-      : []
+    ) {
+      return [index]
+    }
+    return []
   })
 
 const moveAttachedLabels = ({

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/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts

@@ -232,13 +232,17 @@ export const generatePerpendicularTraceDetours = ({
       ]),
     ].filter((coordinate): coordinate is number => coordinate !== undefined)
 
+    const remainingPath = path.slice(index + 2)
+    // A terminal segment has no following leg to reconnect the detour.
+    if (remainingPath.length === 0) remainingPath.push(end)
+
     return [...new Set(detourCoordinates)].map((detour) =>
       simplifyPath([
         ...path.slice(0, index + 1),
         { ...start, [movingAxis]: gate },
         { ...start, [movingAxis]: gate, [detourAxis]: detour },
         { ...end, [detourAxis]: detour },
-        ...path.slice(index + 2),
+        ...remainingPath,
       ]),
     )
   }

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.187",
+  "version": "0.0.189",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/SchematicTracePipelineSolver/repro-robot-controller-imu-tof.page.tsx

@@ -0,0 +1,7 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+import inputProblem from "../../tests/repros/assets/repro-robot-controller-imu-tof.input.json"
+
+export default () => (
+  <PipelineDebugger inputProblem={inputProblem as InputProblem} />
+)

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} />