@tscircuit/schematic-trace-solver 0.0.125 → 0.0.127

package/lib/solvers/TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver.ts

@@ -0,0 +1,216 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { GraphicsObject } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { preservesLabelAnchors } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import type { InputProblem } from "lib/types/InputProblem"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import type { CompletedTraceReroute } from "./types"
+import { generateElbowTransitionSimplificationCandidates } from "./generateElbowTransitionSimplificationCandidates"
+
+interface TraceElbowTransitionSimplificationSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  completedReroutes: CompletedTraceReroute[]
+  netLabelPlacements: NetLabelPlacement[]
+  paddingBuffer: number
+}
+
+const PATH_LENGTH_EPSILON = 1e-9
+
+const getPathLength = (points: Point[]) =>
+  points.slice(1).reduce((length, point, pointIndex) => {
+    const previousPoint = points[pointIndex]!
+    return (
+      length +
+      Math.abs(point.x - previousPoint.x) +
+      Math.abs(point.y - previousPoint.y)
+    )
+  }, 0)
+
+/**
+ * Post-processes traces after trace/label overlap avoidance. It removes
+ * redundant elbow transitions and, when needed, shifts a simplified elbow
+ * around a rendered label. Every replacement is revalidated against labels,
+ * components, other-net traces, and label anchors.
+ */
+export class TraceElbowTransitionSimplificationSolver extends BaseSolver {
+  private input: TraceElbowTransitionSimplificationSolverInput
+  private outputTraces: SolvedTracePath[]
+  private traceIdQueue: string[]
+  private obstacles: ReturnType<typeof getObstacleRects>
+
+  constructor(input: TraceElbowTransitionSimplificationSolverInput) {
+    super()
+    this.input = input
+    this.outputTraces = [...input.traces]
+    const reroutedTraceIds = new Set(
+      input.completedReroutes.map(
+        (completedReroute) => completedReroute.initialTrace.mspPairId,
+      ),
+    )
+    this.traceIdQueue = input.traces
+      .map((trace) => trace.mspPairId)
+      .filter((traceId) => reroutedTraceIds.has(traceId))
+    this.obstacles = getObstacleRects(input.inputProblem)
+  }
+
+  override _step() {
+    const traceId = this.traceIdQueue.shift()
+    if (!traceId) {
+      this.solved = true
+      return
+    }
+
+    const traceIndex = this.outputTraces.findIndex(
+      (trace) => trace.mspPairId === traceId,
+    )
+    const trace = this.outputTraces[traceIndex]!
+    const tracePath = simplifyPath(trace.tracePath)
+    const initialOverlaps = detectTraceLabelOverlap({
+      traces: [{ ...trace, tracePath }],
+      netLabels: this.input.netLabelPlacements,
+    })
+    const otherNetTraces = this.outputTraces.filter(
+      (otherTrace) =>
+        otherTrace.mspPairId !== trace.mspPairId &&
+        otherTrace.globalConnNetId !== trace.globalConnNetId,
+    )
+    const candidateByPath = new Map<string, Point[]>()
+    const completedReroutes = this.input.completedReroutes.filter(
+      (completedReroute) =>
+        completedReroute.initialTrace.mspPairId === trace.mspPairId,
+    )
+
+    for (const completedReroute of completedReroutes) {
+      const initialReroutePath = simplifyPath(
+        completedReroute.initialTrace.tracePath,
+      )
+      const reroutedPath = simplifyPath(completedReroute.reroutedTracePath)
+      const initialRerouteOverlapCount = detectTraceLabelOverlap({
+        traces: [
+          { ...completedReroute.initialTrace, tracePath: initialReroutePath },
+        ],
+        netLabels: this.input.netLabelPlacements,
+      }).length
+
+      const candidates = generateElbowTransitionSimplificationCandidates({
+        trace: completedReroute.initialTrace,
+        label: completedReroute.label,
+        netLabelPlacements: this.input.netLabelPlacements,
+        paddingBuffer: this.input.paddingBuffer,
+        detourCount: completedReroute.detourCount,
+      })
+      for (const candidate of candidates) {
+        const simplifiedCandidate = simplifyPath(candidate)
+        const candidateTrace = {
+          ...completedReroute.initialTrace,
+          tracePath: simplifiedCandidate,
+        }
+        const candidateOverlapCount = detectTraceLabelOverlap({
+          traces: [candidateTrace],
+          netLabels: this.input.netLabelPlacements,
+        }).length
+        const isSimplerEquivalentReroute =
+          candidateOverlapCount < initialRerouteOverlapCount &&
+          Math.abs(
+            getPathLength(simplifiedCandidate) - getPathLength(reroutedPath),
+          ) < PATH_LENGTH_EPSILON &&
+          simplifiedCandidate.length < reroutedPath.length &&
+          preservesLabelAnchors(
+            this.input.netLabelPlacements,
+            [completedReroute.initialTrace],
+            [candidateTrace],
+          )
+
+        if (isSimplerEquivalentReroute) {
+          candidateByPath.set(
+            simplifiedCandidate
+              .map((point) => `${point.x},${point.y}`)
+              .join(";"),
+            simplifiedCandidate,
+          )
+        }
+      }
+    }
+
+    const initialOverlapIds = new Set(
+      initialOverlaps.map(
+        ({ label }) => `${label.globalConnNetId}:${label.netId}`,
+      ),
+    )
+    const initialPathLength = getPathLength(tracePath)
+
+    const validCandidates = [...candidateByPath.values()].filter(
+      (candidatePath) => {
+        const candidateTrace = { ...trace, tracePath: candidatePath }
+        const candidateOverlaps = detectTraceLabelOverlap({
+          traces: [candidateTrace],
+          netLabels: this.input.netLabelPlacements,
+        })
+        const candidateOnlyKeepsExistingOverlaps = candidateOverlaps.every(
+          ({ label }) =>
+            initialOverlapIds.has(`${label.globalConnNetId}:${label.netId}`),
+        )
+        const reducesCollisions =
+          candidateOverlaps.length < initialOverlaps.length
+        const simplifiesGeometry =
+          candidateOverlaps.length === initialOverlaps.length &&
+          getPathLength(candidatePath) <=
+            initialPathLength + PATH_LENGTH_EPSILON &&
+          candidatePath.length < tracePath.length
+
+        return (
+          candidateOnlyKeepsExistingOverlaps &&
+          (reducesCollisions || simplifiesGeometry) &&
+          preservesLabelAnchors(
+            this.input.netLabelPlacements,
+            [trace],
+            [candidateTrace],
+          ) &&
+          !isPathCollidingWithObstacles(candidatePath, this.obstacles) &&
+          !doesPathCoincideWithTraces(candidatePath, otherNetTraces)
+        )
+      },
+    )
+
+    const getOverlapCount = (candidatePath: Point[]) =>
+      detectTraceLabelOverlap({
+        traces: [{ ...trace, tracePath: candidatePath }],
+        netLabels: this.input.netLabelPlacements,
+      }).length
+    validCandidates.sort((a, b) => {
+      const overlapDifference = getOverlapCount(a) - getOverlapCount(b)
+      if (overlapDifference !== 0) return overlapDifference
+      return getPathLength(a) - getPathLength(b) || a.length - b.length
+    })
+
+    const bestCandidate = validCandidates[0]
+    if (!bestCandidate) return
+
+    this.outputTraces[traceIndex] = { ...trace, tracePath: bestCandidate }
+    this.stats.simplifiedTraceCount = (this.stats.simplifiedTraceCount ?? 0) + 1
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.netLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.input.inputProblem)
+    graphics.lines ??= []
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({ points: trace.tracePath, strokeColor: "purple" })
+    }
+    return graphics
+  }
+}

package/lib/solvers/TraceElbowTransitionSimplificationSolver/generateElbowTransitionSimplificationCandidates.ts

@@ -0,0 +1,186 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  isHorizontal,
+  isVertical,
+  segmentIntersectsRect,
+} from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { shiftSegmentOrth } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/pathOps"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+
+export const isSimpleFiveSegmentElbow = (path: Point[]): boolean => {
+  const simplifiedPath = simplifyPath(path)
+  if (simplifiedPath.length !== 6) return false
+
+  const segmentIsHorizontal = simplifiedPath
+    .slice(0, -1)
+    .map((point, index) => isHorizontal(point, simplifiedPath[index + 1]!))
+
+  return segmentIsHorizontal.every(
+    (isHorizontalSegment, index) =>
+      index === 0 || isHorizontalSegment !== segmentIsHorizontal[index - 1],
+  )
+}
+
+const generateSegmentShiftCandidates = ({
+  trace,
+  label,
+  paddingBuffer,
+  detourCount,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  if (trace.globalConnNetId === label.globalConnNetId) return []
+
+  const path = simplifyPath(trace.tracePath)
+  if (!isSimpleFiveSegmentElbow(path)) return []
+
+  const labelBounds = getRectBounds(label.center, label.width, label.height)
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding,
+  }
+  const candidates: Point[][] = []
+
+  for (let segmentIndex = 1; segmentIndex < path.length - 2; segmentIndex++) {
+    const segmentStart = path[segmentIndex]!
+    const segmentEnd = path[segmentIndex + 1]!
+    if (!segmentIntersectsRect(segmentStart, segmentEnd, labelBounds)) continue
+
+    const isHorizontalSegment = isHorizontal(segmentStart, segmentEnd)
+    const isVerticalSegment = isVertical(segmentStart, segmentEnd)
+    if (!isHorizontalSegment && !isVerticalSegment) continue
+
+    const axis = isHorizontalSegment ? "y" : "x"
+    const coordinates = isHorizontalSegment
+      ? [paddedLabelBounds.minY, paddedLabelBounds.maxY]
+      : [paddedLabelBounds.minX, paddedLabelBounds.maxX]
+
+    for (const coordinate of coordinates) {
+      const shiftedPath = shiftSegmentOrth(path, segmentIndex, axis, coordinate)
+      if (shiftedPath) candidates.push(shiftedPath)
+    }
+  }
+
+  return candidates
+}
+
+const generateTransitionShiftCandidates = ({
+  trace,
+  label,
+  paddingBuffer,
+  detourCount,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  const path = simplifyPath(trace.tracePath)
+  if (!isSimpleFiveSegmentElbow(path)) return []
+
+  const labelBounds = getRectBounds(label.center, label.width, label.height)
+  const effectivePadding = paddingBuffer + detourCount * paddingBuffer
+  const paddedLabelBounds = {
+    minX: labelBounds.minX - effectivePadding,
+    maxX: labelBounds.maxX + effectivePadding,
+    minY: labelBounds.minY - effectivePadding,
+    maxY: labelBounds.maxY + effectivePadding,
+  }
+  const start = path[0]!
+  const end = path[path.length - 1]!
+  const middleSegmentIndex = 2
+  const candidates: Point[][] = []
+
+  for (let segmentIndex = 0; segmentIndex < path.length - 1; segmentIndex++) {
+    const segmentStart = path[segmentIndex]!
+    const segmentEnd = path[segmentIndex + 1]!
+    if (!segmentIntersectsRect(segmentStart, segmentEnd, labelBounds)) continue
+    if (Math.abs(segmentIndex - middleSegmentIndex) !== 1) continue
+
+    const isHorizontalSegment = isHorizontal(segmentStart, segmentEnd)
+    const isVerticalSegment = isVertical(segmentStart, segmentEnd)
+    if (!isHorizontalSegment && !isVerticalSegment) continue
+
+    const axis = isHorizontalSegment ? "x" : "y"
+    const min = isHorizontalSegment
+      ? paddedLabelBounds.minX
+      : paddedLabelBounds.minY
+    const max = isHorizontalSegment
+      ? paddedLabelBounds.maxX
+      : paddedLabelBounds.maxY
+    const startCoordinate = isHorizontalSegment ? start.x : start.y
+    const endCoordinate = isHorizontalSegment ? end.x : end.y
+    const corridorCoordinates: number[] = []
+
+    if (startCoordinate < min) {
+      corridorCoordinates.push((startCoordinate + min) / 2)
+    } else if (startCoordinate > max) {
+      corridorCoordinates.push((startCoordinate + max) / 2)
+    }
+    if (endCoordinate < min) {
+      corridorCoordinates.push((endCoordinate + min) / 2)
+    } else if (endCoordinate > max) {
+      corridorCoordinates.push((endCoordinate + max) / 2)
+    }
+
+    for (const coordinate of new Set(corridorCoordinates)) {
+      const shiftedPath = shiftSegmentOrth(
+        path,
+        middleSegmentIndex,
+        axis,
+        coordinate,
+      )
+      if (shiftedPath) candidates.push(shiftedPath)
+    }
+  }
+
+  return candidates
+}
+
+export const generateElbowTransitionSimplificationCandidates = ({
+  trace,
+  label,
+  netLabelPlacements,
+  paddingBuffer,
+  detourCount,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  netLabelPlacements: NetLabelPlacement[]
+  paddingBuffer: number
+  detourCount: number
+}): Point[][] => {
+  const transitionCandidates = generateTransitionShiftCandidates({
+    trace,
+    label,
+    paddingBuffer,
+    detourCount,
+  })
+
+  return transitionCandidates.flatMap((tracePath) => {
+    const shiftedTrace = { ...trace, tracePath }
+    const shiftedOverlaps = detectTraceLabelOverlap({
+      traces: [shiftedTrace],
+      netLabels: netLabelPlacements,
+    })
+
+    return shiftedOverlaps.flatMap(({ label: shiftedLabel }) =>
+      generateSegmentShiftCandidates({
+        trace: shiftedTrace,
+        label: shiftedLabel,
+        paddingBuffer,
+        detourCount,
+      }),
+    )
+  })
+}

package/lib/solvers/TraceElbowTransitionSimplificationSolver/types.ts

@@ -0,0 +1,10 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+export interface CompletedTraceReroute {
+  initialTrace: SolvedTracePath
+  reroutedTracePath: Point[]
+  label: NetLabelPlacement
+  detourCount: number
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -122,6 +122,9 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     const solvedTraces = this.subSolvers.flatMap((s) => s.getOutput().allTraces)
     return {
       traces: [...this.cleanTraces, ...solvedTraces],
+      completedReroutes: this.subSolvers.flatMap(
+        (solver) => solver.completedReroutes,
+      ),
       netLabelPlacements:
         this.labelMergingSolver?.getOutput().netLabelPlacements ??
         this.netLabelPlacements,

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/OverlapAvoidanceStepSolver/OverlapAvoidanceStepSolver.ts

@@ -8,6 +8,7 @@ import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
 import { SingleOverlapSolver } from "../SingleOverlapSolver/SingleOverlapSolver"
 import { doesTraceStartOrEndInLabel } from "./doesTraceStartOrEndInLabel"
 import { visualizeDecomposition } from "./visualizeDecomposition"
+import type { CompletedTraceReroute } from "lib/solvers/TraceElbowTransitionSimplificationSolver/types"
 
 type Overlap = ReturnType<typeof detectTraceLabelOverlap>[0]
 
@@ -35,6 +36,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
   allTraces: SolvedTracePath[]
   tracesToAvoidOverlapping: SolvedTracePath[]
   modifiedTraces: SolvedTracePath[] = []
+  completedReroutes: CompletedTraceReroute[] = []
 
   private readonly PADDING_BUFFER = 0.1
   private detourCounts: Map<string, number> = new Map()
@@ -66,6 +68,17 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
       if (this.activeSubSolver.solved) {
         const solvedPath = this.activeSubSolver.solvedTracePath
         if (solvedPath) {
+          this.completedReroutes.push({
+            initialTrace: {
+              ...this.activeSubSolver.initialTrace,
+              tracePath: this.activeSubSolver.initialTrace.tracePath.map(
+                (point) => ({ ...point }),
+              ),
+            },
+            reroutedTracePath: solvedPath.map((point) => ({ ...point })),
+            label: this.activeSubSolver.label,
+            detourCount: this.activeSubSolver.detourCount,
+          })
           const traceIndex = this.allTraces.findIndex(
             (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
           )
@@ -154,6 +167,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount,
             tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
+            netLabelPlacements: this.initialNetLabelPlacements,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -197,6 +211,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
             paddingBuffer: this.PADDING_BUFFER,
             detourCount: detourCount,
             tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
+            netLabelPlacements: this.initialNetLabelPlacements,
           })
         } else {
           const overlapId = `${traceToFix.mspPairId}-${labelToAvoid.globalConnNetId}`
@@ -217,6 +232,7 @@ export class OverlapAvoidanceStepSolver extends BaseSolver {
         paddingBuffer: this.PADDING_BUFFER,
         detourCount: detourCount,
         tracesToAvoidOverlapping: this.tracesToAvoidOverlapping,
+        netLabelPlacements: this.initialNetLabelPlacements,
       })
     }
   }

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts

@@ -19,9 +19,22 @@ interface SingleOverlapSolverInput {
   paddingBuffer: number
   detourCount: number
   tracesToAvoidOverlapping?: SolvedTracePath[]
+  netLabelPlacements?: NetLabelPlacement[]
 }
 
 const MAX_TRIES = 5
+const PATH_LENGTH_EPSILON = 1e-9
+
+const getPathLength = (points: Point[]) => {
+  let length = 0
+  for (let pointIndex = 0; pointIndex < points.length - 1; pointIndex++) {
+    const point = points[pointIndex]!
+    const nextPoint = points[pointIndex + 1]!
+    length += Math.abs(nextPoint.x - point.x) + Math.abs(nextPoint.y - point.y)
+  }
+  return length
+}
+
 /**
  * This solver attempts to find a valid rerouting for a single trace that is
  * overlapping with a net label. It tries various candidate paths until it
@@ -35,6 +48,8 @@ export class SingleOverlapSolver extends BaseSolver {
   obstacles: ReturnType<typeof getObstacleRects>
   label: NetLabelPlacement
   tracesToAvoidOverlapping: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  detourCount: number
   _tried: number = 0
 
   constructor(solverInput: SingleOverlapSolverInput) {
@@ -42,9 +57,14 @@ export class SingleOverlapSolver extends BaseSolver {
     this.initialTrace = solverInput.trace
     this.problem = solverInput.problem
     this.label = solverInput.label
+    this.detourCount = solverInput.detourCount
     this.tracesToAvoidOverlapping = (
       solverInput.tracesToAvoidOverlapping ?? []
     ).filter((t) => t.globalConnNetId !== solverInput.trace.globalConnNetId)
+    this.netLabelPlacements = solverInput.netLabelPlacements ?? [
+      solverInput.label,
+    ]
+    this.obstacles = getObstacleRects(this.problem)
 
     // Calculate an effective padding for this specific run based on the detourCount.
     const effectivePadding =
@@ -56,20 +76,33 @@ export class SingleOverlapSolver extends BaseSolver {
       paddingBuffer: effectivePadding, // Use the calculated, larger padding
     })
 
-    const getPathLength = (pts: Point[]) => {
-      let len = 0
-      for (let i = 0; i < pts.length - 1; i++) {
-        const dx = pts[i + 1].x - pts[i].x
-        const dy = pts[i + 1].y - pts[i].y
-        len += Math.sqrt(dx * dx + dy * dy)
-      }
-      return len
+    const getLabelOverlapCount = (path: Point[]) =>
+      detectTraceLabelOverlap({
+        traces: [{ ...this.initialTrace, tracePath: path }],
+        netLabels: this.netLabelPlacements,
+      }).length
+
+    const candidateByPath = new Map<string, Point[]>()
+    for (const candidate of candidates) {
+      const simplifiedCandidate = simplifyPath(candidate)
+      candidateByPath.set(
+        simplifiedCandidate.map((point) => `${point.x},${point.y}`).join(";"),
+        simplifiedCandidate,
+      )
     }
 
-    this.queuedCandidatePaths = candidates.sort(
-      (a, b) => getPathLength(a) - getPathLength(b),
-    )
-    this.obstacles = getObstacleRects(this.problem)
+    this.queuedCandidatePaths = [...candidateByPath.values()].sort((a, b) => {
+      const pathLengthDifference = getPathLength(a) - getPathLength(b)
+      if (Math.abs(pathLengthDifference) >= PATH_LENGTH_EPSILON) {
+        return pathLengthDifference
+      }
+
+      const overlapCountDifference =
+        getLabelOverlapCount(a) - getLabelOverlapCount(b)
+      if (overlapCountDifference !== 0) return overlapCountDifference
+
+      return a.length - b.length
+    })
   }
 
   override _step() {
@@ -91,9 +124,19 @@ export class SingleOverlapSolver extends BaseSolver {
         traces: [{ ...this.initialTrace, tracePath: simplifiedPath }],
         netLabels: [this.label],
       }).length > 0
+    const initialPath = simplifyPath(this.initialTrace.tracePath)
+    const initialLabelOverlaps = detectTraceLabelOverlap({
+      traces: [{ ...this.initialTrace, tracePath: initialPath }],
+      netLabels: this.netLabelPlacements,
+    })
+    const candidateLabelOverlaps = detectTraceLabelOverlap({
+      traces: [{ ...this.initialTrace, tracePath: simplifiedPath }],
+      netLabels: this.netLabelPlacements,
+    })
 
     if (
       !stillOverlapsLabel &&
+      candidateLabelOverlaps.length <= initialLabelOverlaps.length &&
       !isPathCollidingWithObstacles(simplifiedPath, this.obstacles) &&
       !doesPathCoincideWithTraces(simplifiedPath, this.tracesToAvoidOverlapping)
     ) {
@@ -128,7 +171,7 @@ export class SingleOverlapSolver extends BaseSolver {
     })
 
     // Draw next candidate
-    if (this.queuedCandidatePaths.length > 0) {
+    if (!this.solvedTracePath && this.queuedCandidatePaths.length > 0) {
       graphics.lines.push({
         points: this.queuedCandidatePaths[0],
         strokeColor: "orange",

package/lib/types/InputProblem.ts

@@ -34,6 +34,30 @@ export interface InputDirectConnection {
   pinIds: [PinId, PinId]
   netId?: string
   netLabelWidth?: number
+
+  /**
+   * When true, this point-to-point connection may be labeled with an "inline
+   * net label": the net name is drawn parallel to (and offset from) the routed
+   * trace instead of being placed as a separate anchored net label at the end
+   * of the trace.
+   *
+   * Only set this for connections whose net name is worth showing on the wire -
+   * the solver trusts the caller (e.g. @tscircuit/core) to make that decision.
+   * An inline label is only emitted when the connection actually got routed.
+   */
+  allowInlineNetLabel?: boolean
+
+  /**
+   * Extent of the inline net label along the trace. Falls back to
+   * `netLabelWidth`, then to an estimate from the netId text.
+   */
+  inlineNetLabelWidth?: number
+
+  /**
+   * Height of the inline net label text. Defaults to
+   * DEFAULT_INLINE_NET_LABEL_HEIGHT.
+   */
+  inlineNetLabelHeight?: number
 }
 
 export interface InputNetConnection {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.125",
+  "version": "0.0.127",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/bug-reports/bug-report-20260806T093501Z.page.tsx

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

package/site/examples/inline-net-label01.page.tsx

@@ -0,0 +1,6 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/inline-net-label01.json"
+
+export { inputProblem }
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />