@tscircuit/schematic-trace-solver 0.0.159 → 0.0.161

package/lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts

@@ -485,13 +485,15 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
         inlineBounds.some((bounds) =>
           pathIntersectsBounds(connector.tracePath, bounds),
         ) ||
-        inputProblem.chips.some((chip) =>
-          pathIntersectsBounds(connector.tracePath, {
-            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,
-          }),
+        inputProblem.chips.some(
+          (chip) =>
+            !ownerChipIds.has(chip.chipId) &&
+            pathIntersectsBounds(connector.tracePath, {
+              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,
+            }),
         ) ||
         (inputProblem.textBoxes ?? []).some((textBox) =>
           pathIntersectsBounds(connector.tracePath, getTextBoxBounds(textBox)),

package/lib/solvers/InlineNetLabelSolver/pushInlineTerminalLabelsAwayFromAnchoredLabels.ts

@@ -0,0 +1,295 @@
+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 LABEL_CLEARANCE = 0.05
+const MAX_OUTWARD_DISTANCE = 5
+
+const getStubDirection = (path: [Point, Point]): StubDirection => {
+  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 getLabelBounds = (placement: {
+  center: Point
+  width: number
+  height: number
+  axis?: "x" | "y"
+}): Bounds => {
+  const renderedWidth =
+    placement.axis === "y" ? placement.height : placement.width
+  const renderedHeight =
+    placement.axis === "y" ? placement.width : placement.height
+  return {
+    minX: placement.center.x - renderedWidth / 2,
+    maxX: placement.center.x + renderedWidth / 2,
+    minY: placement.center.y - renderedHeight / 2,
+    maxY: placement.center.y + renderedHeight / 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) => {
+  for (let index = 0; index < path.length - 1; index++) {
+    if (
+      boundsOverlap(getPathBounds([path[index]!, path[index + 1]!]), bounds)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+const shiftPoint = (
+  point: Point,
+  direction: StubDirection,
+  distance: number,
+): Point => {
+  switch (direction) {
+    case "x+":
+      return { x: point.x + distance, y: point.y }
+    case "x-":
+      return { x: point.x - distance, y: point.y }
+    case "y+":
+      return { x: point.x, y: point.y + distance }
+    case "y-":
+      return { x: point.x, y: point.y - distance }
+  }
+}
+
+const shiftTerminalPlacement = (
+  placement: InlineNetLabelPlacement,
+  direction: StubDirection,
+  distance: number,
+): InlineNetLabelPlacement => {
+  const [start, end] = placement.stubTracePath!
+  const shiftedEnd = shiftPoint(end, direction, distance)
+  return {
+    ...placement,
+    stubTracePath: [start, shiftedEnd],
+    anchorPoint: shiftPoint(placement.anchorPoint, direction, distance),
+    center: shiftPoint(placement.center, direction, distance),
+  }
+}
+
+const getRequiredOutwardDistance = (
+  movingBounds: Bounds,
+  obstacleBounds: Bounds,
+  direction: StubDirection,
+) => {
+  switch (direction) {
+    case "x+":
+      return obstacleBounds.maxX - movingBounds.minX + LABEL_CLEARANCE
+    case "x-":
+      return movingBounds.maxX - obstacleBounds.minX + LABEL_CLEARANCE
+    case "y+":
+      return obstacleBounds.maxY - movingBounds.minY + LABEL_CLEARANCE
+    case "y-":
+      return movingBounds.maxY - obstacleBounds.minY + LABEL_CLEARANCE
+  }
+}
+
+/**
+ * Moves a row of terminal inline labels farther outward when a retained
+ * anchored label occupies their near-pin column. Every terminal on the same
+ * component side moves together, preserving the row's alignment. Only the
+ * newly added stub segment and shifted text are collision-checked; the
+ * original pin-to-label segment was already validated when it was created.
+ * All points and bounds are in schematic-world millimetres, with +x right and
+ * +y up.
+ */
+export const pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
+  inputProblem,
+  traces,
+  anchoredNetLabelPlacements,
+  inlineNetLabelPlacements,
+}: {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  anchoredNetLabelPlacements: NetLabelPlacement[]
+  inlineNetLabelPlacements: InlineNetLabelPlacement[]
+}): {
+  inlineNetLabelPlacements: InlineNetLabelPlacement[]
+  movedGroupCount: number
+} => {
+  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 inlineNetLabelPlacements.entries()) {
+    if (!placement.stubTracePath || placement.pinIds.length !== 1) continue
+    const direction = getStubDirection(placement.stubTracePath)
+    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 outputPlacements = [...inlineNetLabelPlacements]
+  let movedGroupCount = 0
+
+  for (const group of groups.values()) {
+    const groupPlacementIndices = new Set(
+      group.map(({ placementIndex }) => placementIndex),
+    )
+    const fixedInlinePlacements = outputPlacements.filter(
+      (_, placementIndex) => !groupPlacementIndices.has(placementIndex),
+    )
+    const direction = group[0]!.direction
+    let distance = 0
+
+    for (
+      let iteration = 0;
+      iteration <= anchoredNetLabelPlacements.length;
+      iteration++
+    ) {
+      let requiredAdditionalDistance = 0
+      for (const { placement } of group) {
+        const shiftedPlacement = shiftTerminalPlacement(
+          placement,
+          direction,
+          distance,
+        )
+        const shiftedBounds = getLabelBounds(shiftedPlacement)
+        for (const anchoredPlacement of anchoredNetLabelPlacements) {
+          if (anchoredPlacement.globalConnNetId === placement.globalConnNetId) {
+            continue
+          }
+          const anchoredBounds = getLabelBounds(anchoredPlacement)
+          if (!boundsOverlap(shiftedBounds, anchoredBounds)) continue
+          requiredAdditionalDistance = Math.max(
+            requiredAdditionalDistance,
+            getRequiredOutwardDistance(
+              shiftedBounds,
+              anchoredBounds,
+              direction,
+            ),
+          )
+        }
+      }
+      if (requiredAdditionalDistance <= 0) break
+      distance += requiredAdditionalDistance
+    }
+
+    if (distance <= 0 || distance > MAX_OUTWARD_DISTANCE) continue
+
+    const proposals = group.map(({ placement }) =>
+      shiftTerminalPlacement(placement, direction, distance),
+    )
+    const hasConflict = proposals.some((proposal, proposalIndex) => {
+      const originalPlacement = group[proposalIndex]!.placement
+      const originalEnd = originalPlacement.stubTracePath![1]
+      const shiftedEnd = proposal.stubTracePath![1]
+      const addedStubSegment: [Point, Point] = [originalEnd, shiftedEnd]
+      const labelBounds = getLabelBounds(proposal)
+      const ownerChipId = group[proposalIndex]!.ownerChipId
+
+      if (
+        anchoredNetLabelPlacements.some((anchoredPlacement) => {
+          if (anchoredPlacement.globalConnNetId === proposal.globalConnNetId) {
+            return false
+          }
+          const anchoredBounds = getLabelBounds(anchoredPlacement)
+          return (
+            boundsOverlap(labelBounds, anchoredBounds) ||
+            doesPathIntersectBounds(addedStubSegment, anchoredBounds)
+          )
+        })
+      ) {
+        return true
+      }
+
+      for (const chip of inputProblem.chips) {
+        if (chip.chipId === ownerChipId) continue
+        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) ||
+          doesPathIntersectBounds(addedStubSegment, chipBounds)
+        ) {
+          return true
+        }
+      }
+
+      for (const textBox of inputProblem.textBoxes ?? []) {
+        const textBounds = getTextBoxBounds(textBox)
+        if (
+          boundsOverlap(labelBounds, textBounds) ||
+          doesPathIntersectBounds(addedStubSegment, textBounds)
+        ) {
+          return true
+        }
+      }
+
+      for (const trace of traces) {
+        if (trace.globalConnNetId === proposal.globalConnNetId) continue
+        if (
+          doesPathIntersectBounds(trace.tracePath, labelBounds) ||
+          doesPathIntersectBounds(
+            trace.tracePath,
+            getPathBounds(addedStubSegment),
+          )
+        ) {
+          return true
+        }
+      }
+
+      for (const fixedPlacement of fixedInlinePlacements) {
+        const fixedBounds = getLabelBounds(fixedPlacement)
+        if (
+          boundsOverlap(labelBounds, fixedBounds) ||
+          doesPathIntersectBounds(addedStubSegment, fixedBounds) ||
+          (fixedPlacement.stubTracePath &&
+            doesPathIntersectBounds(fixedPlacement.stubTracePath, labelBounds))
+        ) {
+          return true
+        }
+      }
+
+      return false
+    })
+
+    if (hasConflict) continue
+    for (const [groupIndex, { placementIndex }] of group.entries()) {
+      outputPlacements[placementIndex] = proposals[groupIndex]!
+    }
+    movedGroupCount++
+  }
+
+  return {
+    inlineNetLabelPlacements: outputPlacements,
+    movedGroupCount,
+  }
+}

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -10,6 +10,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { getConnectivityMapsFromInputProblem } from "../MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import { getNetLabelWidthForConnection } from "lib/utils/getNetLabelWidthForConnection"
+import { getTraceConnectedPinComponents } from "lib/solvers/SchematicTraceLinesSolver/getTraceConnectedPinComponents"
 
 /**
  * A group of traces that have at least one overlapping segment and
@@ -164,41 +165,12 @@ export class NetLabelPlacementSolver extends BaseSolver {
       ) as string[]
       const pinsInNet = allIdsInNet.filter((id) => pinIdToPinMap.has(id))
 
-      // Build adjacency from solved traces (edges)
-      const adj: Record<string, Set<string>> = {}
-      for (const pid of pinsInNet) adj[pid] = new Set()
-      for (const t of byGlobal[globalConnNetId] ?? []) {
-        const a = t.pins[0].pinId
-        const b = t.pins[1].pinId
-        if (adj[a] && adj[b]) {
-          adj[a].add(b)
-          adj[b].add(a)
-        }
-      }
-
-      // Find connected components based on trace edges
-      const visited = new Set<string>()
-      for (const pid of pinsInNet) {
-        if (visited.has(pid)) continue
-        const stack = [pid]
-        const component = new Set<string>()
-        visited.add(pid)
-        while (stack.length > 0) {
-          const u = stack.pop()!
-          component.add(u)
-          for (const v of adj[u] ?? []) {
-            if (!visited.has(v)) {
-              visited.add(v)
-              stack.push(v)
-            }
-          }
-        }
-
-        // Collect traces fully inside this component
-        const compTraces = (byGlobal[globalConnNetId] ?? []).filter(
-          (t) =>
-            component.has(t.pins[0].pinId) && component.has(t.pins[1].pinId),
-        )
+      for (const traceConnectedComponent of getTraceConnectedPinComponents({
+        pinIds: pinsInNet,
+        traces: byGlobal[globalConnNetId] ?? [],
+      })) {
+        const component = new Set(traceConnectedComponent.pinIds)
+        const compTraces = traceConnectedComponent.traces
 
         if (compTraces.length > 0) {
           // This routed trace exists specifically because two endpoint labels

package/lib/solvers/SchematicTraceLinesSolver/getTraceConnectedPinComponents.ts

@@ -0,0 +1,60 @@
+import type { SolvedTracePath } from "./SchematicTraceLinesSolver"
+import type { PinId } from "lib/types/InputProblem"
+
+export interface TraceConnectedPinComponent {
+  pinIds: PinId[]
+  traces: SolvedTracePath[]
+}
+
+/**
+ * Partitions pins into connected components using solved traces as graph edges.
+ * Pins without a solved trace are returned as singleton components.
+ */
+export const getTraceConnectedPinComponents = ({
+  pinIds,
+  traces,
+}: {
+  pinIds: PinId[]
+  traces: SolvedTracePath[]
+}): TraceConnectedPinComponent[] => {
+  const adjacency = new Map<PinId, Set<PinId>>()
+  for (const pinId of pinIds) adjacency.set(pinId, new Set())
+
+  const relevantTraces = traces.filter((trace) => {
+    if (trace.pins.length !== 2) return false
+    const [firstPin, secondPin] = trace.pins
+    return adjacency.has(firstPin.pinId) && adjacency.has(secondPin.pinId)
+  })
+  for (const trace of relevantTraces) {
+    const [firstPin, secondPin] = trace.pins
+    adjacency.get(firstPin.pinId)!.add(secondPin.pinId)
+    adjacency.get(secondPin.pinId)!.add(firstPin.pinId)
+  }
+
+  const components: TraceConnectedPinComponent[] = []
+  const visited = new Set<PinId>()
+  for (const pinId of pinIds) {
+    if (visited.has(pinId)) continue
+    const componentPinIds: PinId[] = []
+    const pending = [pinId]
+    visited.add(pinId)
+    while (pending.length > 0) {
+      const currentPinId = pending.pop()!
+      componentPinIds.push(currentPinId)
+      for (const adjacentPinId of adjacency.get(currentPinId) ?? []) {
+        if (visited.has(adjacentPinId)) continue
+        visited.add(adjacentPinId)
+        pending.push(adjacentPinId)
+      }
+    }
+
+    const componentPinIdSet = new Set(componentPinIds)
+    components.push({
+      pinIds: componentPinIds,
+      traces: relevantTraces.filter((trace) =>
+        trace.pins.every((pin) => componentPinIdSet.has(pin.pinId)),
+      ),
+    })
+  }
+  return components
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getFixedLabelCoordinate.ts

@@ -53,6 +53,12 @@ export const getFixedLabelCoordinate = (
 ) => {
   const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]))
   const groupTraceIds = new Set(group.map((segment) => segment.traceId))
+  const groupIsWithinSingleComponent = [...groupTraceIds].every(
+    (traceId) =>
+      traceMap
+        .get(traceId)
+        ?.pins.every((pin) => pin.chipId === group[0]!.componentId) === true,
+  )
   const groupHasOnlySingleRailTraces = [...groupTraceIds].every(
     (traceId) => traceMap.get(traceId)?.tracePath.length === 4,
   )
@@ -66,16 +72,27 @@ export const getFixedLabelCoordinate = (
     netLabelPlacements,
     traces,
   )
-  const anchoringLabels = linkedLabels.filter(
-    (label) =>
-      label.orientation === group[0]!.componentFacingDirection &&
-      label.mspConnectionPairIds.some((traceId) => {
-        const trace = traceMap.get(traceId)
-        return (
-          trace && tracePathContainsPoint(trace.tracePath, label.anchorPoint)
-        )
-      }),
+  const labelsOrientedAlongRail = new Set(
+    linkedLabels.filter(
+      (label) =>
+        (orientation === "vertical" &&
+          (label.orientation === "y+" || label.orientation === "y-")) ||
+        (orientation === "horizontal" &&
+          (label.orientation === "x+" || label.orientation === "x-")),
+    ),
   )
+  const anchoringLabels = linkedLabels.filter((label) => {
+    if (
+      label.orientation !== group[0]!.componentFacingDirection &&
+      (!groupIsWithinSingleComponent || !labelsOrientedAlongRail.has(label))
+    ) {
+      return false
+    }
+    return label.mspConnectionPairIds.some((traceId) => {
+      const trace = traceMap.get(traceId)
+      return trace && tracePathContainsPoint(trace.tracePath, label.anchorPoint)
+    })
+  })
   const coordinates = getDistinctCoordinates(
     anchoringLabels.map((label) =>
       orientation === "vertical" ? label.anchorPoint.x : label.anchorPoint.y,
@@ -95,11 +112,24 @@ export const getFixedLabelCoordinate = (
       (traceId) => (traceMap.get(traceId)?.tracePath.length ?? 0) > 4,
     ),
   )
-  // A multi-turn label trace is an intentional routed backbone, so its rail
-  // coordinate may propagate through the local component chain. Labels riding
-  // a single movable rail remain subject to the per-connection locality gate.
+  // A multi-turn label trace is an intentional routed backbone, so its
+  // coordinate may propagate through the connected rail group.
   if (labelIsAnchoredToRoutedBackbone) return coordinate
 
+  // A label at a same-component rail end may set the shared bus coordinate.
+  if (anchoringLabels.some((label) => labelsOrientedAlongRail.has(label))) {
+    const railGroupSpan =
+      Math.max(...group.map((segment) => segment.maxAlong)) -
+      Math.min(...group.map((segment) => segment.minAlong))
+    const coordinateIsLocalToRailGroup = group.every(
+      (segment) =>
+        Math.abs(segment.coordinate - coordinate) <=
+        railGroupSpan + RAIL_ALIGNMENT_EPSILON,
+    )
+    if (coordinateIsLocalToRailGroup) return coordinate
+    return null
+  }
+
   // Rail cleanup is local: a label cannot pull a connection farther than the
   // span of the pins that connection already joins.
   const coordinateIsLocalToEveryTrace = group.every((segment) => {
@@ -110,5 +140,6 @@ export const getFixedLabelCoordinate = (
       distance(trace.pins[0]!, trace.pins[1]!) + RAIL_ALIGNMENT_EPSILON
     )
   })
-  return coordinateIsLocalToEveryTrace ? coordinate : null
+  if (coordinateIsLocalToEveryTrace) return coordinate
+  return null
 }

package/lib/types/InputProblem.ts

@@ -110,10 +110,11 @@ export interface InputNetConnection {
   netLabelHeight?: number
 
   /**
-   * When true, a named one- or two-pin net may use inline labels. A single-pin
-   * net gets an outward stub. A routed two-pin net gets one label along its
-   * trace; when that route is intentionally skipped, both endpoints get
-   * outward stubs. Nets with more than two pins retain anchored labels.
+   * 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.
    */
   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.159",
+  "version": "0.0.161",
   "type": "module",
   "scripts": {
     "start": "cosmos",