@tscircuit/schematic-trace-solver 0.0.187 → 0.0.189

package/lib/solvers/InlineNetLabelSolver/alignPortOnlyInlineNetLabelStubs.ts

@@ -4,6 +4,7 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 import type { InputProblem } from "lib/types/InputProblem"
 import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
 import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
+import { isLabelRepresentedInline } from "./isLabelRepresentedInline"
 
 type StubDirection = "x+" | "x-" | "y+" | "y-"
 
@@ -126,13 +127,8 @@ export const alignPortOnlyInlineNetLabelStubs = ({
   }
 
   const alignedPlacements = [...placements]
-  const supersededGlobalNetIds = new Set(
-    placements.map((placement) => placement.globalConnNetId),
-  )
   const retainedAnchoredLabelBounds = netLabelPlacements
-    .filter(
-      (placement) => !supersededGlobalNetIds.has(placement.globalConnNetId),
-    )
+    .filter((placement) => !isLabelRepresentedInline(placement, placements))
     .map(getLabelBounds)
 
   for (const group of groups.values()) {

package/lib/solvers/InlineNetLabelSolver/getAnchoredNetLabelRenderedBounds.ts

@@ -19,6 +19,19 @@ export const getAnchoredNetLabelRenderedBounds = (
   placement: NetLabelPlacement,
 ): Bounds => {
   if (placement.orientation !== "x-" && placement.orientation !== "x+") {
+    // Named vertical tags render their long text extent along y. Width-only
+    // placeholders retain the supplied envelope instead.
+    if (placement.netLabelText && placement.width > placement.height) {
+      const width = placement.height
+      const height = placement.width
+      const center = getCenterFromAnchor(
+        placement.anchorPoint,
+        placement.orientation,
+        width,
+        height,
+      )
+      return getRectBounds(center, width, height)
+    }
     return getRectBounds(placement.center, placement.width, placement.height)
   }
 

package/lib/solvers/InlineNetLabelSolver/getInlineLabelObstacles.ts

@@ -0,0 +1,64 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
+
+/** A terminal wire is separate from remote routes, even on the same net. */
+export const getInlineTerminalBounds = (label: InlineNetLabelPlacement) => {
+  if (!label.stubTracePath) return null
+  // Give a line a nonzero box for the axis-aligned rectangle intersection test.
+  const epsilon = 1e-6
+  return {
+    minX: Math.min(...label.stubTracePath.map((p) => p.x)) - epsilon,
+    maxX: Math.max(...label.stubTracePath.map((p) => p.x)) + epsilon,
+    minY: Math.min(...label.stubTracePath.map((p) => p.y)) - epsilon,
+    maxY: Math.max(...label.stubTracePath.map((p) => p.y)) + epsilon,
+  }
+}
+
+/** Geometric obstacles for already placed inline text and its terminal wires. */
+export const getInlineLabelObstacles = (
+  inputProblem: InputProblem,
+  placements: InlineNetLabelPlacement[],
+) => {
+  const fixedLabels: NetLabelPlacement[] = placements.map((label) => ({
+    globalConnNetId: label.globalConnNetId,
+    netId: label.netId,
+    pinIds: label.pinIds,
+    mspConnectionPairIds: [],
+    anchorPoint: label.anchorPoint,
+    orientation: "y+",
+    center: label.center,
+    width: label.axis === "x" ? label.width : label.height,
+    height: label.axis === "x" ? label.height : label.width,
+  }))
+  const terminalTraces: SolvedTracePath[] = placements.flatMap((label) => {
+    if (!label.stubTracePath) return []
+    const chip = inputProblem.chips.find((chip) =>
+      chip.pins.some((pin) => label.pinIds.includes(pin.pinId)),
+    )
+    const pin = chip?.pins.find((pin) => label.pinIds.includes(pin.pinId))
+    if (!chip || !pin) return []
+    const id = JSON.stringify([
+      "inline-terminal",
+      label.globalConnNetId,
+      [...label.pinIds].sort(),
+    ])
+    return [
+      {
+        mspPairId: id,
+        mspConnectionPairIds: [id],
+        globalConnNetId: label.globalConnNetId,
+        dcConnNetId: label.globalConnNetId,
+        pinIds: label.pinIds,
+        pins: [
+          { ...pin, chipId: chip.chipId },
+          { ...pin, ...label.stubTracePath[1], chipId: chip.chipId },
+        ],
+        tracePath: label.stubTracePath,
+      },
+    ]
+  })
+
+  return { fixedLabels, terminalTraces }
+}

package/lib/solvers/InlineNetLabelSolver/getLocalTraceLabelShifts.ts

@@ -0,0 +1,407 @@
+import type { Bounds, Point } from "@tscircuit/math-utils"
+import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
+import type { InputProblem } from "lib/types/InputProblem"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
+import {
+  getInlineLabelObstacles,
+  getInlineTerminalBounds,
+} from "./getInlineLabelObstacles"
+import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver"
+import type {
+  InlineNetLabelOutput,
+  InlineNetLabelPlacement,
+} from "./InlineNetLabelSolver"
+
+type Output = Omit<InlineNetLabelOutput, "inputProblem">
+const EPS = 1e-6
+const CLEARANCE = 0.05
+const hits = (path: Point[], bounds: Bounds) =>
+  path.slice(1).some((p, i) => segmentIntersectsRect(path[i]!, p, bounds))
+const same = (a: Point, b: Point) => Math.hypot(a.x - b.x, a.y - b.y) < EPS
+const translate = (p: Point, axis: "x" | "y", distance: number) => ({
+  ...p,
+  [axis]: p[axis] + distance,
+})
+const intersections = (a: Point[], b: Point[]) =>
+  a.slice(1).flatMap((p, i) =>
+    b.slice(1).flatMap((q, j) => {
+      const point = getSegmentIntersection(a[i]!, p, b[j]!, q)
+      return point ? [point] : []
+    }),
+  )
+
+/**
+ * Propose a sideways shift of an existing leg and its connected rail. Never add corners,
+ * route around a component, or search beyond the obstructing label column.
+ * A leaf power label may move sideways with its existing short connector.
+ * The caller must replan inline labels before committing a proposal.
+ */
+export function* getLocalTraceLabelShifts(
+  inputProblem: InputProblem,
+  output: Output,
+  pendingInlinePlacements: InlineNetLabelPlacement[] = [],
+): Generator<Output> {
+  const placements = [
+    ...output.inlineNetLabelPlacements,
+    ...pendingInlinePlacements,
+  ]
+  const { fixedLabels, terminalTraces } = getInlineLabelObstacles(
+    inputProblem,
+    placements,
+  )
+  const terminalBounds = placements.flatMap((label) => {
+    const bounds = getInlineTerminalBounds(label)
+    return bounds ? [{ label, bounds }] : []
+  })
+  const obstacles = [
+    ...inputProblem.chips.map((chip) => ({
+      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 ?? []).map((box) => getTextBoxBounds(box)),
+  ]
+  const inlineBounds = fixedLabels.map((label) => ({
+    minX: label.center.x - label.width / 2,
+    maxX: label.center.x + label.width / 2,
+    minY: label.center.y - label.height / 2,
+    maxY: label.center.y + label.height / 2,
+  }))
+  const pinPositions = [
+    ...inputProblem.chips.flatMap((chip) => chip.pins),
+    ...output.traces.flatMap((trace) => trace.pins),
+  ]
+  for (const trace of output.traces) {
+    const path = simplifyPath(trace.tracePath)
+    for (let i = 0; i < path.length - 1; i++) {
+      const a = path[i]!,
+        b = path[i + 1]!
+      const axis = Math.abs(a.x - b.x) < EPS ? "x" : "y"
+      const along = axis === "x" ? "y" : "x"
+      if (Math.abs(a[axis] - b[axis]) > EPS || same(a, b)) continue
+      const blocking = [
+        ...output.netLabelPlacements
+          .filter((label) => label.globalConnNetId !== trace.globalConnNetId)
+          .map(getAnchoredNetLabelRenderedBounds),
+        ...inlineBounds,
+        ...terminalBounds
+          .filter(
+            ({ label }) =>
+              !trace.pinIds.some((pinId) => label.pinIds.includes(pinId)),
+          )
+          .map(({ bounds }) => bounds),
+      ].filter((bounds) => segmentIntersectsRect(a, b, bounds))
+      if (!blocking.length) continue
+      // Cleanup can split one rail across several trace records, including a
+      // branch that starts at a junction instead of at its pin. Shift the
+      // connected collinear rail and its branch ends together.
+      let low = Math.min(a[along], b[along])
+      let high = Math.max(a[along], b[along])
+      let expanded = true
+      while (expanded) {
+        expanded = false
+        for (const other of output.traces) {
+          if (other.globalConnNetId !== trace.globalConnNetId) continue
+          for (let j = 1; j < other.tracePath.length; j++) {
+            const p = other.tracePath[j - 1]!,
+              q = other.tracePath[j]!
+            if (
+              Math.abs(p[axis] - a[axis]) > EPS ||
+              Math.abs(q[axis] - a[axis]) > EPS
+            )
+              continue
+            const min = Math.min(p[along], q[along]),
+              max = Math.max(p[along], q[along])
+            if (max < low - EPS || min > high + EPS) continue
+            if (min < low || max > high) expanded = true
+            low = Math.min(low, min)
+            high = Math.max(high, max)
+          }
+        }
+      }
+      const onRail = (p: Point) =>
+        Math.abs(p[axis] - a[axis]) < EPS &&
+        p[along] >= low - EPS &&
+        p[along] <= high + EPS
+      if (pinPositions.some(onRail)) continue
+      const minKey = axis === "x" ? "minX" : "minY"
+      const maxKey = axis === "x" ? "maxX" : "maxY"
+      const localWidth = Math.max(
+        ...blocking.map((bounds) => bounds[maxKey] - bounds[minKey]),
+      )
+      const railLabelBounds = output.netLabelPlacements
+        .filter(
+          (label) =>
+            label.globalConnNetId === trace.globalConnNetId &&
+            onRail(label.anchorPoint),
+        )
+        .map(getAnchoredNetLabelRenderedBounds)
+      const coordinates = [
+        ...new Set(
+          blocking.flatMap((bounds) => [
+            bounds[minKey] - CLEARANCE,
+            bounds[maxKey] + CLEARANCE,
+            ...railLabelBounds
+              .filter((own) => boundsOverlap(own, bounds))
+              .flatMap((own) => [
+                a[axis] + bounds[minKey] - CLEARANCE - own[maxKey],
+                a[axis] + bounds[maxKey] + CLEARANCE - own[minKey],
+              ]),
+          ]),
+        ),
+      ].sort((x, y) => Math.abs(x - a[axis]) - Math.abs(y - a[axis]))
+      for (const coordinate of coordinates) {
+        const distance = coordinate - a[axis]
+        if (Math.abs(distance) > localWidth + 2 * CLEARANCE) continue
+        const traces = output.traces.map((other) => {
+          if (
+            other.globalConnNetId !== trace.globalConnNetId ||
+            !other.tracePath.some(onRail)
+          )
+            return other
+          return {
+            ...other,
+            tracePath: other.tracePath.map((p) =>
+              onRail(p) ? translate(p, axis, distance) : p,
+            ),
+          }
+        })
+        const shiftedPaths = traces
+          .filter((other, index) => other !== output.traces[index])
+          .map((other) => other.tracePath)
+        let labels = output.netLabelPlacements.map((label) => {
+          if (
+            label.globalConnNetId !== trace.globalConnNetId ||
+            !onRail(label.anchorPoint)
+          )
+            return label
+          return {
+            ...label,
+            anchorPoint: translate(label.anchorPoint, axis, distance),
+            center: translate(label.center, axis, distance),
+          }
+        })
+        let blocked = false
+        const movedOwnLabelBounds = labels.flatMap((label, index) =>
+          label !== output.netLabelPlacements[index]
+            ? [getAnchoredNetLabelRenderedBounds(label)]
+            : [],
+        )
+        // A movable leaf label can make room for the shifted leg. Its last
+        // segment must already run parallel to that leg: extend the existing
+        // approach and translate the stem, retaining its orientation and bends.
+        for (const [labelIndex, label] of labels.entries()) {
+          if (label.globalConnNetId === trace.globalConnNetId) continue
+          const bounds = getAnchoredNetLabelRenderedBounds(label)
+          const clearanceEdges = movedOwnLabelBounds
+            .filter((own) => boundsOverlap(own, bounds))
+            .map((own) => own[distance > 0 ? maxKey : minKey])
+          if (
+            shiftedPaths.some((p) => hits(p, bounds)) &&
+            !output.traces.some(
+              (other) =>
+                other.globalConnNetId === trace.globalConnNetId &&
+                hits(other.tracePath, bounds),
+            )
+          )
+            clearanceEdges.push(coordinate)
+          if (!clearanceEdges.length) continue
+          const connectorIndex = traces.findIndex(
+            (candidate) =>
+              candidate.globalConnNetId === label.globalConnNetId &&
+              candidate.pinIds.length === 1 &&
+              candidate.tracePath.length === 3 &&
+              same(candidate.tracePath.at(-1)!, label.anchorPoint),
+          )
+          const connector = traces[connectorIndex]
+          if (!connector) {
+            const placementSolver = new NetLabelNetLabelCollisionSolver({
+              inputProblem,
+              traces: [...traces, ...terminalTraces],
+              netLabelPlacements: labels,
+              fixedNetLabelPlacements: fixedLabels,
+              useRenderedLabelBounds: true,
+            })
+            const nearby = placementSolver.getNearbyValidPlacements(
+              label,
+              localWidth + Math.max(label.width, label.height),
+            )[0]
+            if (!nearby) {
+              blocked = true
+              break
+            }
+            labels[labelIndex] = nearby
+            continue
+          }
+          const [start, bend, end] = connector.tracePath as [
+            Point,
+            Point,
+            Point,
+          ]
+          if (
+            Math.abs(bend[axis] - end[axis]) > EPS ||
+            Math.abs(start[along] - bend[along]) > EPS
+          ) {
+            blocked = true
+            break
+          }
+          const delta =
+            distance > 0
+              ? Math.max(...clearanceEdges) + CLEARANCE - bounds[minKey]
+              : Math.min(...clearanceEdges) - CLEARANCE - bounds[maxKey]
+          if (
+            Math.abs(delta) >
+            localWidth + bounds[maxKey] - bounds[minKey] + 2 * CLEARANCE
+          ) {
+            blocked = true
+            break
+          }
+          const moved = {
+            ...label,
+            anchorPoint: translate(label.anchorPoint, axis, delta),
+            center: translate(label.center, axis, delta),
+          }
+          labels[labelIndex] = moved
+          traces[connectorIndex] = {
+            ...connector,
+            tracePath: [start, translate(bend, axis, delta), moved.anchorPoint],
+          }
+        }
+        if (blocked) continue
+        for (const [index, proposed] of traces.entries()) {
+          const original = output.traces[index]!
+          if (proposed === original) continue
+          const candidate = proposed.tracePath
+          const previous = original.tracePath
+          if (
+            candidate
+              .slice(1)
+              .some(
+                (p, index) =>
+                  Math.abs(p.x - candidate[index]!.x) > EPS &&
+                  Math.abs(p.y - candidate[index]!.y) > EPS,
+              )
+          ) {
+            blocked = true
+            break
+          }
+          // Keep existing pin exits and all shared junctions. In particular,
+          // moving a rail must not disconnect a pin midway along it.
+          const dot = (a: Point, b: Point, c: Point, d: Point) =>
+            (b.x - a.x) * (d.x - c.x) + (b.y - a.y) * (d.y - c.y)
+          if (
+            dot(previous[0]!, previous[1]!, candidate[0]!, candidate[1]!) <=
+              EPS ||
+            dot(
+              previous.at(-1)!,
+              previous.at(-2)!,
+              candidate.at(-1)!,
+              candidate.at(-2)!,
+            ) <= EPS
+          ) {
+            blocked = true
+            break
+          }
+          const junctions = output.traces
+            .filter(
+              (other) =>
+                other !== original &&
+                other.globalConnNetId === original.globalConnNetId,
+            )
+            .flatMap((other) => [
+              ...other.tracePath,
+              ...intersections(previous, other.tracePath),
+            ])
+            .filter((p) => tracePathContainsPoint(previous, p))
+            .map((p) =>
+              original.globalConnNetId === trace.globalConnNetId && onRail(p)
+                ? translate(p, axis, distance)
+                : p,
+            )
+          const protectedPoints = [
+            ...pinPositions.filter((p) => tracePathContainsPoint(previous, p)),
+            ...junctions,
+          ]
+          if (
+            protectedPoints.some(
+              (p) => !tracePathContainsPoint(candidate, p),
+            ) ||
+            pinPositions.some((p) => {
+              const clearance = {
+                minX: p.x - CLEARANCE,
+                maxX: p.x + CLEARANCE,
+                minY: p.y - CLEARANCE,
+                maxY: p.y + CLEARANCE,
+              }
+              return hits(candidate, clearance) && !hits(previous, clearance)
+            }) ||
+            obstacles.some(
+              (bounds) => hits(candidate, bounds) && !hits(previous, bounds),
+            )
+          ) {
+            blocked = true
+            break
+          }
+          for (const other of [...traces, ...terminalTraces]) {
+            if (
+              other.mspPairId === proposed.mspPairId ||
+              other.globalConnNetId === proposed.globalConnNetId
+            )
+              continue
+            const originalOther =
+              output.traces.find((t) => t.mspPairId === other.mspPairId) ??
+              other
+            if (
+              doesPathCoincideWithTraces(candidate, [other]) ||
+              intersections(candidate, other.tracePath).length >
+                intersections(previous, originalOther.tracePath).length
+            ) {
+              blocked = true
+              break
+            }
+          }
+          if (blocked) break
+        }
+        if (blocked) continue
+        for (const [index, label] of labels.entries()) {
+          if (label === output.netLabelPlacements[index]) continue
+          const bounds = getAnchoredNetLabelRenderedBounds(label)
+          if (
+            obstacles.some((obstacle) => boundsOverlap(bounds, obstacle)) ||
+            inlineBounds.some((other) => boundsOverlap(bounds, other))
+          ) {
+            blocked = true
+            break
+          }
+          if (
+            labels.some(
+              (other, j) =>
+                index !== j &&
+                boundsOverlap(bounds, getAnchoredNetLabelRenderedBounds(other)),
+            )
+          ) {
+            blocked = true
+            break
+          }
+          if (
+            [...traces, ...terminalTraces].some(
+              (other) =>
+                other.globalConnNetId !== label.globalConnNetId &&
+                hits(other.tracePath, bounds),
+            )
+          ) {
+            blocked = true
+            break
+          }
+        }
+        if (!blocked) yield { ...output, traces, netLabelPlacements: labels }
+      }
+    }
+  }
+}

package/lib/solvers/InlineNetLabelSolver/getOutputLabelCollisions.ts

@@ -0,0 +1,145 @@
+import type { InlineNetLabelOutput } from "./InlineNetLabelSolver"
+import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
+import { getInlineTerminalBounds } from "./getInlineLabelObstacles"
+import { boundsOverlap } from "lib/utils/textBoxBounds"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+type LabelIdentity = { globalConnNetId: string; pinIds: string[] }
+type TraceIdentity =
+  | { kind: "routed"; id: string }
+  | { kind: "terminal"; label: LabelIdentity }
+
+export type OutputLabelCollision =
+  | { kind: "label-label"; labels: [LabelIdentity, LabelIdentity] }
+  | {
+      kind: "trace-label"
+      trace: TraceIdentity
+      label: LabelIdentity
+      target: "text" | "terminal"
+    }
+
+const sameLabel = (a: LabelIdentity, b: LabelIdentity) => {
+  const first = [...a.pinIds].sort()
+  const second = [...b.pinIds].sort()
+  return (
+    a.globalConnNetId === b.globalConnNetId &&
+    first.length === second.length &&
+    first.every((pinId, index) => pinId === second[index])
+  )
+}
+
+export const sameOutputLabelCollision = (
+  a: OutputLabelCollision,
+  b: OutputLabelCollision,
+): boolean => {
+  if (a.kind === "label-label" && b.kind === "label-label")
+    return (
+      (sameLabel(a.labels[0], b.labels[0]) &&
+        sameLabel(a.labels[1], b.labels[1])) ||
+      (sameLabel(a.labels[0], b.labels[1]) &&
+        sameLabel(a.labels[1], b.labels[0]))
+    )
+  if (a.kind !== "trace-label" || b.kind !== "trace-label") return false
+  const sameTrace =
+    a.trace.kind === "routed" && b.trace.kind === "routed"
+      ? a.trace.id === b.trace.id
+      : a.trace.kind === "terminal" &&
+        b.trace.kind === "terminal" &&
+        sameLabel(a.trace.label, b.trace.label)
+  return sameTrace && a.target === b.target && sameLabel(a.label, b.label)
+}
+
+/** Identify final geometry conflicts without interpreting opaque identifiers. */
+export const getOutputLabelCollisions = (
+  output: Omit<InlineNetLabelOutput, "inputProblem">,
+) => {
+  const labels = [
+    ...output.netLabelPlacements,
+    ...output.inlineNetLabelPlacements,
+  ].map((label) => ({
+    label,
+    bounds:
+      "axis" in label
+        ? {
+            minX:
+              label.center.x -
+              (label.axis === "x" ? label.width : label.height) / 2,
+            maxX:
+              label.center.x +
+              (label.axis === "x" ? label.width : label.height) / 2,
+            minY:
+              label.center.y -
+              (label.axis === "x" ? label.height : label.width) / 2,
+            maxY:
+              label.center.y +
+              (label.axis === "x" ? label.height : label.width) / 2,
+          }
+        : getAnchoredNetLabelRenderedBounds(label),
+  }))
+  const collisions: OutputLabelCollision[] = []
+  const add = (collision: OutputLabelCollision) => {
+    if (!collisions.some((other) => sameOutputLabelCollision(collision, other)))
+      collisions.push(collision)
+  }
+  for (let i = 0; i < labels.length; i++)
+    for (const other of labels.slice(i + 1)) {
+      if (boundsOverlap(labels[i]!.bounds, other.bounds))
+        add({ kind: "label-label", labels: [labels[i]!.label, other.label] })
+    }
+  const traces = [
+    ...output.traces.map((trace) => ({
+      ...trace,
+      identity: { kind: "routed", id: trace.mspPairId } satisfies TraceIdentity,
+    })),
+    ...output.inlineNetLabelPlacements.flatMap((label) =>
+      label.stubTracePath
+        ? [
+            {
+              identity: { kind: "terminal", label } satisfies TraceIdentity,
+              globalConnNetId: label.globalConnNetId,
+              tracePath: label.stubTracePath,
+            },
+          ]
+        : [],
+    ),
+  ]
+  for (const trace of traces)
+    for (const { label, bounds } of labels) {
+      if (
+        ("axis" in label || label.globalConnNetId !== trace.globalConnNetId) &&
+        trace.tracePath
+          .slice(1)
+          .some((end, index) =>
+            segmentIntersectsRect(trace.tracePath[index]!, end, bounds),
+          )
+      )
+        add({
+          kind: "trace-label",
+          trace: trace.identity,
+          label,
+          target: "text",
+        })
+    }
+  for (const label of output.inlineNetLabelPlacements) {
+    const bounds = getInlineTerminalBounds(label)
+    if (!bounds) continue
+    for (const trace of output.traces) {
+      // A route attached to the terminal's own pin is an intentional connection.
+      if (trace.pinIds.some((pinId) => label.pinIds.includes(pinId))) continue
+      if (
+        trace.tracePath
+          .slice(1)
+          .some((end, index) =>
+            segmentIntersectsRect(trace.tracePath[index]!, end, bounds),
+          )
+      )
+        add({
+          kind: "trace-label",
+          trace: { kind: "routed", id: trace.mspPairId },
+          label,
+          target: "terminal",
+        })
+    }
+  }
+  return collisions
+}

package/lib/solvers/InlineNetLabelSolver/isLabelRepresentedInline.ts

@@ -0,0 +1,15 @@
+import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
+
+/** Every pin represented by the old label must still have the same net name. */
+export const isLabelRepresentedInline = (
+  label: { globalConnNetId: string; pinIds: string[] },
+  inlinePlacements: InlineNetLabelPlacement[],
+) =>
+  label.pinIds.length > 0 &&
+  label.pinIds.every((pinId) =>
+    inlinePlacements.some(
+      (inline) =>
+        inline.globalConnNetId === label.globalConnNetId &&
+        inline.pinIds.includes(pinId),
+    ),
+  )