@tscircuit/schematic-trace-solver 0.0.77 → 0.0.78

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts

@@ -19,6 +19,7 @@ import { chooseHostTraceForGroup } from "./host"
 import { anchorsForSegment } from "./anchors"
 import { solveNetLabelPlacementForPortOnlyPin } from "./solvePortOnlyPin"
 import { visualizeSingleNetLabelPlacementSolver } from "./SingleNetLabelPlacementSolver_visualize"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 export {
   NET_LABEL_HORIZONTAL_WIDTH,
@@ -70,7 +71,12 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
     bounds: { minX: number; minY: number; maxX: number; maxY: number }
     anchor: { x: number; y: number }
     orientation: FacingDirection
-    status: "ok" | "chip-collision" | "trace-collision" | "parallel-to-segment"
+    status:
+      | "ok"
+      | "chip-collision"
+      | "trace-collision"
+      | "text-collision"
+      | "parallel-to-segment"
     hostSegIndex: number
   }> = []
 
@@ -276,6 +282,20 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
               continue
             }
 
+            if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
+              this.testedCandidates.push({
+                center: testCenter,
+                width,
+                height,
+                bounds,
+                anchor,
+                orientation,
+                status: "text-collision",
+                hostSegIndex: si,
+              })
+              continue
+            }
+
             // Trace collision check (ignore the host segment)
             const traceIntersectionResult = rectIntersectsAnyTrace(
               bounds,

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts

@@ -38,7 +38,9 @@ export function visualizeSingleNetLabelPlacementSolver(
           ? "rgba(220, 0, 0, 0.25)"
           : c.status === "trace-collision"
             ? "rgba(220, 140, 0, 0.25)"
-            : "rgba(120, 120, 120, 0.15)"
+            : c.status === "text-collision"
+              ? "rgba(160, 0, 220, 0.2)"
+              : "rgba(120, 120, 120, 0.15)"
     const stroke =
       c.status === "ok"
         ? "green"
@@ -46,7 +48,9 @@ export function visualizeSingleNetLabelPlacementSolver(
           ? "red"
           : c.status === "trace-collision"
             ? "orange"
-            : "gray"
+            : c.status === "text-collision"
+              ? "purple"
+              : "gray"
     const candidateLabel =
       c.status === "ok"
         ? "status: ok(valid net label candidate)"
@@ -54,7 +58,9 @@ export function visualizeSingleNetLabelPlacementSolver(
           ? "status: chip-collision"
           : c.status === "trace-collision"
             ? "status: trace-collision"
-            : "status: parallel-to-segment"
+            : c.status === "text-collision"
+              ? "status: text-collision"
+              : "status: parallel-to-segment"
 
     graphics.rects!.push({
       center: {

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/solvePortOnlyPin.ts

@@ -14,6 +14,7 @@ import {
   getRectBounds,
 } from "./geometry"
 import { rectIntersectsAnyTrace } from "./collisions"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 export function solveNetLabelPlacementForPortOnlyPin(params: {
   inputProblem: InputProblem
@@ -32,7 +33,12 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     bounds: { minX: number; minY: number; maxX: number; maxY: number }
     anchor: { x: number; y: number }
     orientation: FacingDirection
-    status: "ok" | "chip-collision" | "trace-collision" | "parallel-to-segment"
+    status:
+      | "ok"
+      | "chip-collision"
+      | "trace-collision"
+      | "text-collision"
+      | "parallel-to-segment"
     hostSegIndex: number
   }>
   error?: string
@@ -97,7 +103,12 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     bounds: { minX: number; minY: number; maxX: number; maxY: number }
     anchor: { x: number; y: number }
     orientation: FacingDirection
-    status: "ok" | "chip-collision" | "trace-collision" | "parallel-to-segment"
+    status:
+      | "ok"
+      | "chip-collision"
+      | "trace-collision"
+      | "text-collision"
+      | "parallel-to-segment"
     hostSegIndex: number
   }> = []
 
@@ -133,6 +144,20 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
       continue
     }
 
+    if (rectIntersectsAnyTextBox(bounds, inputProblem)) {
+      testedCandidates.push({
+        center,
+        width,
+        height,
+        bounds,
+        anchor,
+        orientation,
+        status: "text-collision",
+        hostSegIndex: -1,
+      })
+      continue
+    }
+
     // Trace collision check
     const traceIntersectionResult = rectIntersectsAnyTrace(
       bounds,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -110,6 +110,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,
       pins,
+      connectionPair,
       chipMap: this.chipMap,
     })
   }

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -2,16 +2,11 @@ import type { GraphicsObject } from "graphics-debug"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { MspConnectionPair } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
-import type {
-  ChipId,
-  InputChip,
-  InputProblem,
-  PinId,
-} from "lib/types/InputProblem"
+import type { InputChip, InputProblem, PinId } from "lib/types/InputProblem"
 import type { Point } from "@tscircuit/math-utils"
 import { calculateElbow } from "calculate-elbow"
 import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
-import { getObstacleRects, type ChipWithBounds } from "./rect"
+import { getObstacleRects, type ObstacleRect } from "./rect"
 import { findFirstCollision, isHorizontal, isVertical } from "./collisions"
 import {
   aabbFromPoints,
@@ -20,32 +15,39 @@ import {
   type Axis,
 } from "./mid"
 import { pathKey, shiftSegmentOrth } from "./pathOps"
+import type { FacingDirection } from "lib/utils/dir"
+import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import type { RectPadding } from "lib/utils/textBoxBounds"
 
 type PathKey = string
 
 export class SchematicTraceSingleLineSolver2 extends BaseSolver {
   pins: MspConnectionPair["pins"]
+  connectionPair?: MspConnectionPair
   inputProblem: InputProblem
   chipMap: Record<string, InputChip>
 
-  obstacles: ChipWithBounds[]
-  rectById: Map<string, ChipWithBounds>
+  obstacles: ObstacleRect[]
+  textObstacles: Set<ObstacleRect>
   aabb: { minX: number; maxX: number; minY: number; maxY: number }
 
   baseElbow: Point[]
 
   solvedTracePath: Point[] | null = null
 
-  private queue: Array<{ path: Point[]; collisionChipIds: Set<ChipId> }> = []
+  private queue: Array<{ path: Point[]; collisionRects: Set<ObstacleRect> }> =
+    []
   private visited: Set<PathKey> = new Set()
 
   constructor(params: {
     pins: MspConnectionPair["pins"]
+    connectionPair?: MspConnectionPair
     inputProblem: InputProblem
     chipMap: Record<string, InputChip>
   }) {
     super()
     this.pins = params.pins
+    this.connectionPair = params.connectionPair
     this.inputProblem = params.inputProblem
     this.chipMap = params.chipMap
 
@@ -57,9 +59,14 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       }
     }
 
-    // Build obstacle rects from chips
-    this.obstacles = getObstacleRects(this.inputProblem)
-    this.rectById = new Map(this.obstacles.map((r) => [r.chipId, r]))
+    // Build obstacle rects from chips and schematic text boxes. Text boxes are
+    // padded by the label footprint for this net so labels have clearance too.
+    this.obstacles = getObstacleRects(this.inputProblem, {
+      textBoxPadding: this.getTextBoxPaddingForConnectionPair(),
+    })
+    this.textObstacles = new Set(
+      this.obstacles.filter((r) => r.kind === "text_box"),
+    )
 
     // Build initial elbow path
     const [pin1, pin2] = this.pins
@@ -84,7 +91,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     )
 
     // Seed search
-    this.queue.push({ path: this.baseElbow, collisionChipIds: new Set() })
+    this.queue.push({ path: this.baseElbow, collisionRects: new Set() })
     this.visited.add(pathKey(this.baseElbow))
   }
 
@@ -94,10 +101,92 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     return {
       chipMap: this.chipMap,
       pins: this.pins,
+      connectionPair: this.connectionPair,
       inputProblem: this.inputProblem,
     }
   }
 
+  private getTextBoxPaddingForConnectionPair(): RectPadding {
+    if (!this.inputProblem.textBoxes?.length) return {}
+
+    const netId = this.connectionPair?.userNetId
+    if (!netId) return {}
+
+    const orientations =
+      this.inputProblem.availableNetLabelOrientations[netId] ??
+      (["x+", "x-", "y+", "y-"] as FacingDirection[])
+    const netLabelWidth = this.getNetLabelWidthForConnectionPair(netId)
+    const netLabelHeight = this.getNetLabelHeightForConnectionPair(netId)
+    const padding: Required<RectPadding> = {
+      minX: 0,
+      minY: 0,
+      maxX: 0,
+      maxY: 0,
+    }
+
+    for (const orientation of orientations) {
+      const { width, height } = getDimsForOrientation({
+        orientation,
+        netLabelWidth,
+        netLabelHeight,
+      })
+
+      if (orientation === "y+" || orientation === "y-") {
+        padding.minX = Math.max(padding.minX, width / 2)
+        padding.maxX = Math.max(padding.maxX, width / 2)
+        if (orientation === "y+") {
+          padding.minY = Math.max(padding.minY, height)
+        } else {
+          padding.maxY = Math.max(padding.maxY, height)
+        }
+      } else {
+        padding.minY = Math.max(padding.minY, height / 2)
+        padding.maxY = Math.max(padding.maxY, height / 2)
+        if (orientation === "x+") {
+          padding.minX = Math.max(padding.minX, width)
+        } else {
+          padding.maxX = Math.max(padding.maxX, width)
+        }
+      }
+    }
+
+    return padding
+  }
+
+  private getNetLabelWidthForConnectionPair(netId: string) {
+    const ncWidth = this.inputProblem.netConnections.find(
+      (nc) => nc.netId === netId,
+    )?.netLabelWidth
+    if (ncWidth !== undefined) return ncWidth
+
+    const dcWidthByNetId = this.inputProblem.directConnections.find(
+      (dc) => dc.netId === netId,
+    )?.netLabelWidth
+    if (dcWidthByNetId !== undefined) return dcWidthByNetId
+
+    const pinIds = this.pins.map((p) => p.pinId)
+    const dcWidthByPinId = this.inputProblem.directConnections.find((dc) =>
+      dc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelWidth
+    if (dcWidthByPinId !== undefined) return dcWidthByPinId
+
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelWidth
+  }
+
+  private getNetLabelHeightForConnectionPair(netId: string) {
+    const ncHeight = this.inputProblem.netConnections.find(
+      (nc) => nc.netId === netId,
+    )?.netLabelHeight
+    if (ncHeight !== undefined) return ncHeight
+
+    const pinIds = this.pins.map((p) => p.pinId)
+    return this.inputProblem.netConnections.find((nc) =>
+      nc.pinIds.some((pid) => pinIds.includes(pid)),
+    )?.netLabelHeight
+  }
+
   private axisOfSegment(a: Point, b: Point): Axis | null {
     if (isVertical(a, b)) return "x"
     if (isHorizontal(a, b)) return "y"
@@ -127,10 +216,18 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       return
     }
 
-    const { path, collisionChipIds } = state
+    const { path, collisionRects } = state
 
     const [PA, PB] = this.pins
-    const collision = findFirstCollision(path, this.obstacles)
+    const collision = findFirstCollision(path, this.obstacles, {
+      excludeRectsForSegment: (segIndex) => {
+        const lastSegIndex = path.length - 2
+        if (segIndex === 0 || segIndex === lastSegIndex) {
+          return this.textObstacles
+        }
+        return new Set<ObstacleRect>()
+      },
+    })
 
     if (!collision) {
       // Sanity check: ensure path still connects PA -> PB
@@ -182,7 +279,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     // Note: PA and PB are already defined above
     const candidates: number[] = []
 
-    if (collisionChipIds.size === 0) {
+    if (collisionRects.size === 0) {
       // First collision on this search branch: use mid(PA, C) and mid(PB, C)
       const m1 = midBetweenPointAndRect(axis, { x: PA.x, y: PA.y }, rect)
       const m2 = midBetweenPointAndRect(axis, { x: PB.x, y: PB.y }, rect)
@@ -193,20 +290,14 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       candidates.push(...uniqueCandidates)
     } else {
       // Subsequent collisions: mid between C and nearest rect/bounds from the set
-      const mids = candidateMidsFromSet(
-        axis,
-        rect,
-        this.rectById,
-        collisionChipIds,
-        this.aabb,
-      )
+      const mids = candidateMidsFromSet(axis, rect, collisionRects, this.aabb)
       candidates.push(...mids)
     }
 
     // Generate new shifted paths, order by total path length (shorter first)
     const newStates: Array<{
       path: Point[]
-      collisionRectIds: Set<string>
+      collisionRects: Set<ObstacleRect>
       len: number
     }> = []
 
@@ -216,15 +307,15 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       const key = pathKey(newPath)
       if (this.visited.has(key)) continue
       this.visited.add(key)
-      const nextSet = new Set(collisionChipIds)
-      nextSet.add(rect.chipId)
+      const nextSet = new Set(collisionRects)
+      nextSet.add(rect)
       const len = this.pathLength(newPath)
-      newStates.push({ path: newPath, collisionRectIds: nextSet, len })
+      newStates.push({ path: newPath, collisionRects: nextSet, len })
     }
 
     newStates.sort((a, b) => a.len - b.len)
     for (const st of newStates) {
-      this.queue.push({ path: st.path, collisionChipIds: st.collisionRectIds })
+      this.queue.push({ path: st.path, collisionRects: st.collisionRects })
     }
   }
 
@@ -254,7 +345,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     })
 
     // Draw all the new candidates
-    for (const { path, collisionChipIds: collisionRectIds } of this.queue) {
+    for (const { path } of this.queue) {
       g.lines!.push({ points: path, strokeColor: "teal", strokeDash: "2 2" })
     }
 

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts

@@ -1,5 +1,5 @@
 import type { Point } from "@tscircuit/math-utils"
-import type { ChipWithBounds } from "./rect"
+import type { RectBounds } from "./rect"
 
 const EPS = 1e-9
 
@@ -8,10 +8,10 @@ export const isVertical = (a: Point, b: Point, eps = EPS) =>
 export const isHorizontal = (a: Point, b: Point, eps = EPS) =>
   Math.abs(a.y - b.y) < eps
 
-export const segmentIntersectsRect = (
+export const segmentIntersectsRect = <TRect extends RectBounds>(
   a: Point,
   b: Point,
-  r: ChipWithBounds,
+  r: TRect,
   eps = EPS,
 ): boolean => {
   const vert = isVertical(a, b, eps)
@@ -35,19 +35,19 @@ export const segmentIntersectsRect = (
   }
 }
 
-export const findFirstCollision = (
+export const findFirstCollision = <TRect extends RectBounds>(
   pts: Point[],
-  rects: ChipWithBounds[],
+  rects: TRect[],
   opts: {
-    excludeRectIdsForSegment?: (segIndex: number) => Set<string>
+    excludeRectsForSegment?: (segIndex: number) => Set<TRect>
   } = {},
-): { segIndex: number; rect: ChipWithBounds } | null => {
+): { segIndex: number; rect: TRect } | null => {
   for (let i = 0; i < pts.length - 1; i++) {
     const a = pts[i]!
     const b = pts[i + 1]!
-    const excluded = opts.excludeRectIdsForSegment?.(i) ?? new Set<string>()
+    const excluded = opts.excludeRectsForSegment?.(i) ?? new Set<TRect>()
     for (const r of rects) {
-      if (excluded.has(r.chipId)) continue
+      if (excluded.has(r)) continue
       if (segmentIntersectsRect(a, b, r)) {
         return { segIndex: i, rect: r }
       }
@@ -61,7 +61,7 @@ export const findFirstCollision = (
  */
 export const isPathCollidingWithObstacles = (
   path: Point[],
-  obstacles: ChipWithBounds[],
+  obstacles: RectBounds[],
 ): boolean => {
   for (let i = 0; i < path.length - 1; i++) {
     for (const obstacle of obstacles) {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/mid.ts

@@ -1,5 +1,5 @@
 import type { Point } from "@tscircuit/math-utils"
-import type { ChipWithBounds } from "./rect"
+import type { ObstacleRect } from "./rect"
 
 const EPS = 1e-9
 
@@ -15,7 +15,7 @@ export const aabbFromPoints = (a: Point, b: Point) => ({
 export const midBetweenPointAndRect = (
   axis: Axis,
   p: Point,
-  r: ChipWithBounds,
+  r: ObstacleRect,
   eps = EPS,
 ): number[] => {
   if (axis === "x") {
@@ -41,15 +41,12 @@ export const midBetweenPointAndRect = (
 
 export const candidateMidsFromSet = (
   axis: Axis,
-  colliding: ChipWithBounds,
-  rectsById: Map<string, ChipWithBounds>,
-  collisionRectIds: Set<string>,
+  colliding: ObstacleRect,
+  collisionRects: Set<ObstacleRect>,
   aabb: { minX: number; maxX: number; minY: number; maxY: number },
   eps = EPS,
 ): number[] => {
-  const setRects = [...collisionRectIds]
-    .map((id) => rectsById.get(id))
-    .filter((r): r is ChipWithBounds => !!r)
+  const setRects = [...collisionRects]
 
   if (axis === "x") {
     const leftBoundaries = [aabb.minX, ...setRects.map((r) => r.maxX)].filter(

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts

@@ -1,19 +1,44 @@
 import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import { getInputChipBounds } from "lib/solvers/GuidelinesSolver/getInputChipBounds"
+import { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
 
-export type ChipWithBounds = {
-  chipId: string
+export type RectBounds = {
   minX: number
   minY: number
   maxX: number
   maxY: number
 }
 
-export const chipToRect = (chip: InputChip): ChipWithBounds => {
+export type ChipObstacleRect = RectBounds & {
+  kind: "chip"
+  chipId: string
+}
+
+export type TextBoxObstacleRect = RectBounds & {
+  kind: "text_box"
+  textBox: NonNullable<InputProblem["textBoxes"]>[number]
+}
+
+export type ObstacleRect = ChipObstacleRect | TextBoxObstacleRect
+
+export const chipToRect = (chip: InputChip): ChipObstacleRect => {
   const b = getInputChipBounds(chip)
-  return { chipId: chip.chipId, ...b }
+  return { kind: "chip", chipId: chip.chipId, ...b }
 }
 
-export const getObstacleRects = (problem: InputProblem): ChipWithBounds[] => {
-  return problem.chips.map(chipToRect)
+export const getObstacleRects = (
+  problem: InputProblem,
+  opts: { textBoxPadding?: RectPadding } = {},
+): ObstacleRect[] => {
+  const chipRects = problem.chips.map(chipToRect)
+  const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
+    const b = getTextBoxBounds(textBox, opts.textBoxPadding)
+    return {
+      kind: "text_box" as const,
+      textBox,
+      ...b,
+    }
+  })
+
+  return [...chipRects, ...textBoxRects]
 }

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver.ts

@@ -20,6 +20,7 @@ import type {
   TraceAnchoredNetLabelOverlapSolverParams,
 } from "./types"
 import { visualizeTraceAnchoredNetLabelOverlapSolver } from "./visualize"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 type ActiveOverlapSearch = {
   overlap: LabelOverlap
@@ -227,6 +228,8 @@ export class TraceAnchoredNetLabelOverlapSolver extends BaseSolver {
   ): CandidateStatus {
     const bounds = getLabelBounds(candidate)
     if (this.intersectsAnyChip(bounds)) return "chip-collision"
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
+      return "text-collision"
     if (traceCrossesBoundsInterior(bounds, this.traces))
       return "trace-collision"
     if (this.intersectsAnyOtherLabel(bounds, labelIndex)) {

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/types.ts

@@ -30,6 +30,7 @@ export type TraceLocation = {
 export type CandidateStatus =
   | "valid"
   | "chip-collision"
+  | "text-collision"
   | "trace-collision"
   | "netlabel-collision"
 

package/lib/solvers/VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver.ts

@@ -23,6 +23,7 @@ import type {
   VccNetLabelCornerPlacementSolverParams,
 } from "./types"
 import { visualizeVccNetLabelCornerPlacementSolver } from "./visualize"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 export class VccNetLabelCornerPlacementSolver extends BaseSolver {
   inputProblem: InputProblem
@@ -171,6 +172,8 @@ export class VccNetLabelCornerPlacementSolver extends BaseSolver {
     labelIndex: number,
   ): CornerCandidateStatus {
     if (this.intersectsAnyChip(bounds)) return "chip-collision"
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
+      return "text-collision"
     if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
       return "trace-collision"
     }

package/lib/solvers/VccNetLabelCornerPlacementSolver/types.ts

@@ -25,6 +25,7 @@ export type TraceCornerCandidate = {
 export type CornerCandidateStatus =
   | "valid"
   | "chip-collision"
+  | "text-collision"
   | "trace-collision"
   | "netlabel-collision"
 

package/lib/utils/textBoxBounds.ts

@@ -0,0 +1,40 @@
+import type { Bounds } from "@tscircuit/math-utils"
+import type { InputProblem, TextBoxes } from "lib/types/InputProblem"
+
+export type RectPadding = {
+  minX?: number
+  minY?: number
+  maxX?: number
+  maxY?: number
+}
+
+export function getTextBoxBounds(
+  textBox: TextBoxes,
+  padding: RectPadding = {},
+): Bounds {
+  return {
+    minX: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
+    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
+    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
+    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0),
+  }
+}
+
+export function boundsOverlap(a: Bounds, b: Bounds, eps = 1e-9): boolean {
+  return (
+    a.minX < b.maxX - eps &&
+    a.maxX > b.minX + eps &&
+    a.minY < b.maxY - eps &&
+    a.maxY > b.minY + eps
+  )
+}
+
+export function rectIntersectsAnyTextBox(
+  bounds: Bounds,
+  inputProblem: InputProblem,
+): boolean {
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true
+  }
+  return false
+}

package/package.json

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