@tscircuit/schematic-trace-solver 0.0.77 → 0.0.79

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -36,6 +36,7 @@ import type {
   EvaluatedCandidate,
 } from "./types"
 import { visualizeAvailableNetOrientationSolver } from "./visualize"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 export class AvailableNetOrientationSolver extends BaseSolver {
   inputProblem: InputProblem
@@ -643,6 +644,9 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
       return "chip-collision"
     }
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
+      return "text-collision"
+    }
     if (this.sharesChipBoundary(bounds)) {
       return "chip-collision"
     }

package/lib/solvers/AvailableNetOrientationSolver/types.ts

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

package/lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts

@@ -14,10 +14,12 @@ import { rectIntersectsAnyTrace } from "lib/solvers/NetLabelPlacementSolver/Sing
 import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 type CandidateStatus =
   | "ok"
   | "chip-collision"
+  | "text-collision"
   | "trace-collision"
   | "label-collision"
 
@@ -37,6 +39,7 @@ const CANDIDATE_STATUS_COLOR: Record<CandidateStatus, string> = {
   "label-collision": "orange",
   "trace-collision": "darkorange",
   "chip-collision": "red",
+  "text-collision": "purple",
 }
 
 const CANDIDATE_STATUS_FILL: Record<CandidateStatus, string> = {
@@ -44,6 +47,7 @@ const CANDIDATE_STATUS_FILL: Record<CandidateStatus, string> = {
   "label-collision": "rgba(255, 160, 0, 0.2)",
   "trace-collision": "rgba(200, 80, 0, 0.2)",
   "chip-collision": "rgba(220, 0, 0, 0.15)",
+  "text-collision": "rgba(128, 0, 128, 0.15)",
 }
 
 type Candidate = {
@@ -269,6 +273,8 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
 
     if (this.chipIndex.getChipsInBounds(bounds).length > 0)
       return "chip-collision"
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
+      return "text-collision"
 
     if (
       rectIntersectsAnyTrace(bounds, this.traceMap, hostPairId, hostSegIndex)

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/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts

@@ -1,14 +1,67 @@
+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 { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { SingleOverlapSolver } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver"
-import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+import {
+  getCenterFromAnchor,
+  getRectBounds,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import type { InputProblem } from "lib/types/InputProblem"
 
+const ON_PATH_EPS = 1e-6
+
+function getClosestPointOnSegment(params: {
+  point: Point
+  segmentStart: Point
+  segmentEnd: Point
+}): Point {
+  const { point, segmentStart, segmentEnd } = params
+  const dx = segmentEnd.x - segmentStart.x
+  const dy = segmentEnd.y - segmentStart.y
+  const segmentLengthSq = dx * dx + dy * dy
+  if (segmentLengthSq === 0) return { x: segmentStart.x, y: segmentStart.y }
+  const projection =
+    ((point.x - segmentStart.x) * dx + (point.y - segmentStart.y) * dy) /
+    segmentLengthSq
+  const clampedProjection = Math.max(0, Math.min(1, projection))
+  return {
+    x: segmentStart.x + clampedProjection * dx,
+    y: segmentStart.y + clampedProjection * dy,
+  }
+}
+
+function getClosestPointOnPath(point: Point, path: Point[]): Point {
+  let closestPoint: Point = path[0]!
+  let closestDistSq = Infinity
+  for (let i = 0; i < path.length - 1; i++) {
+    const candidatePoint = getClosestPointOnSegment({
+      point,
+      segmentStart: path[i]!,
+      segmentEnd: path[i + 1]!,
+    })
+    const dx = candidatePoint.x - point.x
+    const dy = candidatePoint.y - point.y
+    const candidateDistSq = dx * dx + dy * dy
+    if (candidateDistSq < closestDistSq) {
+      closestDistSq = candidateDistSq
+      closestPoint = candidatePoint
+    }
+  }
+  return closestPoint
+}
+
+function isPointOnPath(point: Point, path: Point[]): boolean {
+  const closestPoint = getClosestPointOnPath(point, path)
+  return (
+    Math.hypot(closestPoint.x - point.x, closestPoint.y - point.y) < ON_PATH_EPS
+  )
+}
+
 /**
  * Merges all labels that touch/overlap with each other (transitively) around
  * a seed label into a single bounding-box label. This prevents the situation
@@ -159,10 +212,12 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
             (t) => t.mspPairId === this.activeSubSolver!.initialTrace.mspPairId,
           )
           if (idx !== -1) {
+            const oldPath = this.outputTraces[idx]!.tracePath
             this.outputTraces[idx] = {
               ...this.outputTraces[idx],
               tracePath: solvedPath,
             }
+            this.reanchorLabelsOnMovedTrace(this.outputTraces[idx]!, oldPath)
           }
         }
         this.activeSubSolver = null
@@ -229,6 +284,37 @@ export class NetLabelTraceCollisionSolver extends BaseSolver {
     })
   }
 
+  /**
+   * When a trace is rerouted, net labels that were anchored on the old path
+   * can be left floating in space. Snap their anchor back onto the new path.
+   */
+  private reanchorLabelsOnMovedTrace(
+    movedTrace: SolvedTracePath,
+    oldPath: Point[],
+  ) {
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      const label = this.outputNetLabelPlacements[i]!
+      if (label.globalConnNetId !== movedTrace.globalConnNetId) continue
+      if (isPointOnPath(label.anchorPoint, movedTrace.tracePath)) continue
+      if (!isPointOnPath(label.anchorPoint, oldPath)) continue
+
+      const newAnchor = getClosestPointOnPath(
+        label.anchorPoint,
+        movedTrace.tracePath,
+      )
+      this.outputNetLabelPlacements[i] = {
+        ...label,
+        anchorPoint: newAnchor,
+        center: getCenterFromAnchor(
+          newAnchor,
+          label.orientation,
+          label.width,
+          label.height,
+        ),
+      }
+    }
+  }
+
   getOutput() {
     return {
       traces: this.outputTraces,

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(