@tscircuit/schematic-trace-solver 0.0.31 → 0.0.33

package/lib/index.ts

@@ -1,2 +1,3 @@
 export * from "./solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 export * from "./types/InputProblem"
+export { SchematicTraceSingleLineSolver2 } from "./solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -1,8 +1,14 @@
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
-import type { InputChip, InputPin, InputProblem } from "lib/types/InputProblem"
+import type {
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
 import { ConnectivityMap } from "connectivity-map"
 import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
+import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
 import type { GraphicsObject } from "graphics-debug"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
@@ -104,6 +110,22 @@ export class MspConnectionPairSolver extends BaseSolver {
         // Too far apart; skip creating an MSP pair for this net
         return
       }
+      // Avoid pairs that would cross restricted center lines
+      const pinIdMap = new Map(Object.entries(this.pinMap)) as Map<
+        PinId,
+        InputPin & { chipId: string }
+      >
+      if (
+        doesPairCrossRestrictedCenterLines({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pinIdMap,
+          p1,
+          p2,
+        })
+      ) {
+        return
+      }
 
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1!)!
       const userNetId =
@@ -122,12 +144,41 @@ export class MspConnectionPairSolver extends BaseSolver {
 
     // There are more than 3 pins, so we need to run MSP to find the best pairs
 
+    const pinIdMap = new Map(Object.entries(this.pinMap)) as Map<
+      PinId,
+      InputPin & { chipId: string }
+    >
     const msp = getOrthogonalMinimumSpanningTree(
       directlyConnectedPins.map((p) => this.pinMap[p]!).filter(Boolean),
-      { maxDistance: this.maxMspPairDistance },
+      {
+        maxDistance: this.maxMspPairDistance,
+        forbidEdge: (a, b) =>
+          doesPairCrossRestrictedCenterLines({
+            inputProblem: this.inputProblem,
+            chipMap: this.chipMap,
+            pinIdMap,
+            p1: a as InputPin & { chipId: string },
+            p2: b as InputPin & { chipId: string },
+          }),
+      },
     )
 
     for (const [pin1, pin2] of msp) {
+      const p1Obj = this.pinMap[pin1!]!
+      const p2Obj = this.pinMap[pin2!]!
+      // Skip any edge that would cross a restricted center line (safety filter)
+      if (
+        doesPairCrossRestrictedCenterLines({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pinIdMap,
+          p1: p1Obj,
+          p2: p2Obj,
+        })
+      ) {
+        continue
+      }
+
       const globalConnNetId = this.globalConnMap.getNetConnectedToId(pin1!)!
       const userNetId =
         this.userNetIdByPinId[pin1!] ?? this.userNetIdByPinId[pin2!]
@@ -136,7 +187,7 @@ export class MspConnectionPairSolver extends BaseSolver {
         dcConnNetId: dcNetId,
         globalConnNetId,
         userNetId,
-        pins: [this.pinMap[pin1!]!, this.pinMap[pin2!]!],
+        pins: [p1Obj, p2Obj],
       })
     }
   }

package/lib/solvers/MspConnectionPairSolver/doesPairCrossRestrictedCenterLines.ts

@@ -0,0 +1,62 @@
+import type {
+  InputChip,
+  InputPin,
+  InputProblem,
+  PinId,
+} from "lib/types/InputProblem"
+import { getRestrictedCenterLines } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getRestrictedCenterLines"
+
+export const doesPairCrossRestrictedCenterLines = (params: {
+  inputProblem: InputProblem
+  chipMap: Record<string, InputChip>
+  pinIdMap: Map<PinId, InputPin & { chipId: string }>
+  p1: InputPin & { chipId: string }
+  p2: InputPin & { chipId: string }
+}): boolean => {
+  const { inputProblem, chipMap, pinIdMap, p1, p2 } = params
+
+  const restrictedCenterLines = getRestrictedCenterLines({
+    pins: [p1, p2],
+    inputProblem,
+    pinIdMap,
+    chipMap,
+  })
+
+  if (restrictedCenterLines.size === 0) return false
+
+  const EPS = 1e-9
+
+  const crossesSegment = (
+    a: { x: number; y: number },
+    b: { x: number; y: number },
+  ): boolean => {
+    for (const [, rcl] of restrictedCenterLines) {
+      if (rcl.axes.has("x") && typeof rcl.x === "number") {
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS) return true
+      }
+      if (rcl.axes.has("y") && typeof rcl.y === "number") {
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS) return true
+      }
+    }
+    return false
+  }
+
+  // If already aligned on one axis, just check that single segment
+  if (Math.abs(p1.x - p2.x) < EPS || Math.abs(p1.y - p2.y) < EPS) {
+    return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y })
+  }
+
+  // Two L-shape possibilities: horizontal-then-vertical or vertical-then-horizontal
+  const elbowHV = { x: p2.x, y: p1.y }
+  const elbowVH = { x: p1.x, y: p2.y }
+
+  const hvCrosses =
+    crossesSegment({ x: p1.x, y: p1.y }, elbowHV) ||
+    crossesSegment(elbowHV, { x: p2.x, y: p2.y })
+  const vhCrosses =
+    crossesSegment({ x: p1.x, y: p1.y }, elbowVH) ||
+    crossesSegment(elbowVH, { x: p2.x, y: p2.y })
+
+  // Forbid the pair only if both L-shape routes would cross a restricted center line
+  return hvCrosses && vhCrosses
+}

package/lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts

@@ -18,7 +18,10 @@ import type { InputPin, PinId } from "lib/types/InputProblem"
  */
 export function getOrthogonalMinimumSpanningTree(
   pins: InputPin[],
-  opts: { maxDistance?: number } = {},
+  opts: {
+    maxDistance?: number
+    forbidEdge?: (a: InputPin, b: InputPin) => boolean
+  } = {},
 ): Array<[PinId, PinId]> {
   const n = pins.length
   const maxDistance = opts?.maxDistance ?? Number.POSITIVE_INFINITY
@@ -82,7 +85,9 @@ export function getOrthogonalMinimumSpanningTree(
     for (let v = 0; v < n; v++) {
       if (!inTree[v]) {
         const d0 = manhattan(pins[u], pins[v])
-        const d = d0 > maxDistance ? Number.POSITIVE_INFINITY : d0
+        const isForbidden = opts?.forbidEdge?.(pins[u], pins[v]) ?? false
+        const d =
+          d0 > maxDistance || isForbidden ? Number.POSITIVE_INFINITY : d0
         if (
           d < bestDist[v] ||
           (d === bestDist[v] && pins[u].pinId < pins[parent[v]]?.pinId)

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver.ts

@@ -7,7 +7,7 @@ import type {
   MspConnectionPairId,
 } from "../MspConnectionPairSolver/MspConnectionPairSolver"
 import type { ConnectivityMap } from "connectivity-map"
-import { SchematicTraceSingleLineSolver } from "./SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver"
+import { SchematicTraceSingleLineSolver2 } from "./SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
 import type { Guideline } from "../GuidelinesSolver/GuidelinesSolver"
 import { visualizeGuidelines } from "../GuidelinesSolver/visualizeGuidelines"
 import type { Point } from "@tscircuit/math-utils"
@@ -20,7 +20,6 @@ export interface SolvedTracePath extends MspConnectionPair {
 
 export class SchematicTraceLinesSolver extends BaseSolver {
   inputProblem: InputProblem
-  guidelines: Guideline[]
   mspConnectionPairs: MspConnectionPair[]
 
   dcConnMap: ConnectivityMap
@@ -34,7 +33,7 @@ export class SchematicTraceLinesSolver extends BaseSolver {
   solvedTracePaths: Array<SolvedTracePath> = []
   failedConnectionPairs: Array<MspConnectionPair & { error?: string }> = []
 
-  declare activeSubSolver: SchematicTraceSingleLineSolver | null
+  declare activeSubSolver: SchematicTraceSingleLineSolver2 | null
 
   constructor(params: {
     mspConnectionPairs: MspConnectionPair[]
@@ -42,14 +41,12 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     dcConnMap: ConnectivityMap
     globalConnMap: ConnectivityMap
     inputProblem: InputProblem
-    guidelines: Guideline[]
   }) {
     super()
     this.inputProblem = params.inputProblem
     this.mspConnectionPairs = params.mspConnectionPairs
     this.dcConnMap = params.dcConnMap
     this.globalConnMap = params.globalConnMap
-    this.guidelines = params.guidelines
     this.chipMap = params.chipMap
 
     this.queuedConnectionPairs = [...this.mspConnectionPairs]
@@ -64,7 +61,6 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       mspConnectionPairs: this.mspConnectionPairs,
       dcConnMap: this.dcConnMap,
       globalConnMap: this.globalConnMap,
-      guidelines: this.guidelines,
     }
   }
 
@@ -101,20 +97,20 @@ export class SchematicTraceLinesSolver extends BaseSolver {
     }
 
     const connectionPair = this.queuedConnectionPairs.shift()
-    this.currentConnectionPair = connectionPair!
 
     if (!connectionPair) {
       this.solved = true
       return
     }
 
+    this.currentConnectionPair = connectionPair
+
     const { pins } = connectionPair
 
-    this.activeSubSolver = new SchematicTraceSingleLineSolver({
+    this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,
       pins,
       chipMap: this.chipMap,
-      guidelines: this.guidelines,
     })
   }
 
@@ -127,8 +123,6 @@ export class SchematicTraceLinesSolver extends BaseSolver {
       connectionAlpha: 0.1,
     })
 
-    visualizeGuidelines({ guidelines: this.guidelines, graphics })
-
     for (const { mspPairId, tracePath } of this.solvedTracePaths) {
       graphics.lines!.push({
         points: tracePath,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -97,6 +97,7 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
     const { elbowVariants, movableSegments } = generateElbowVariants({
       baseElbow: this.baseElbow,
       guidelines: this.guidelines,
+      maxVariants: 1000,
     })
 
     this.movableSegments = movableSegments
@@ -144,6 +145,9 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       chipMap: this.chipMap,
     })
 
+    // Check if this candidate path is valid
+    let pathIsValid = true
+
     for (let i = 0; i < nextCandidatePath.length - 1; i++) {
       const start = nextCandidatePath[i]
       const end = nextCandidatePath[i + 1]
@@ -156,14 +160,22 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       for (const [, rcl] of restrictedCenterLines) {
         if (rcl.axes.has("x") && typeof rcl.x === "number") {
           // segment strictly crosses vertical center line
-          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS) return
+          if ((start.x - rcl.x) * (end.x - rcl.x) < -EPS) {
+            pathIsValid = false
+            break
+          }
         }
         if (rcl.axes.has("y") && typeof rcl.y === "number") {
           // segment strictly crosses horizontal center line
-          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS) return
+          if ((start.y - rcl.y) * (end.y - rcl.y) < -EPS) {
+            pathIsValid = false
+            break
+          }
         }
       }
 
+      if (!pathIsValid) break
+
       // Always exclude chips that contain the start or end points of this segment
       // if those points are actually pin locations
       const isStartPin = this.pins.some(
@@ -197,13 +209,18 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
             (onRight && dx < -EPS) ||
             (onBottom && dy > EPS) ||
             (onTop && dy < -EPS)
-          if (entersInterior) return
+          if (entersInterior) {
+            pathIsValid = false
+            break
+          }
           if (!excludeChipIds.includes(startPin.chipId)) {
             excludeChipIds.push(startPin.chipId)
           }
         }
       }
 
+      if (!pathIsValid) break
+
       if (isEndPin) {
         const endPin = this.pins.find(
           (pin) =>
@@ -224,24 +241,37 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
             (onRight && dx < -EPS) ||
             (onBottom && dy > EPS) ||
             (onTop && dy < -EPS)
-          if (entersInterior) return
+          if (entersInterior) {
+            pathIsValid = false
+            break
+          }
           if (!excludeChipIds.includes(endPin.chipId)) {
             excludeChipIds.push(endPin.chipId)
           }
         }
       }
 
+      if (!pathIsValid) break
+
       const obstacleOps = { excludeChipIds }
       const intersects =
         this.chipObstacleSpatialIndex.doesOrthogonalLineIntersectChip(
           [start, end],
           obstacleOps,
         )
-      if (intersects) return
+      if (intersects) {
+        pathIsValid = false
+        break
+      }
     }
 
-    this.solvedTracePath = nextCandidatePath
-    this.solved = true
+    // If this path is valid, use it as the solution
+    if (pathIsValid) {
+      this.solvedTracePath = nextCandidatePath
+      this.solved = true
+    }
+    // If this path is invalid, continue to next step to try the next candidate
+    // The next _step() call will try the next candidate path
   }
 
   override visualize(): GraphicsObject {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts

@@ -260,9 +260,11 @@ const cartesian = <T>(arrays: T[][]): T[][] =>
 export const generateElbowVariants = ({
   baseElbow,
   guidelines,
+  maxVariants = 10000,
 }: {
   baseElbow: Point[]
   guidelines: Guideline[]
+  maxVariants?: number
 }): {
   elbowVariants: Array<Point[]>
   movableSegments: Array<MovableSegment>
@@ -395,6 +397,11 @@ export const generateElbowVariants = ({
     if (!seen.has(key)) {
       seen.add(key)
       elbowVariants.push(variant)
+
+      // Stop if we've hit the maximum number of variants
+      if (elbowVariants.length >= maxVariants) {
+        break
+      }
     }
   }
 

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

@@ -0,0 +1,239 @@
+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 { Point } from "@tscircuit/math-utils"
+import { calculateElbow } from "calculate-elbow"
+import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
+import { getObstacleRects, type ChipWithBounds } from "./rect"
+import { findFirstCollision, isHorizontal, isVertical } from "./collisions"
+import {
+  aabbFromPoints,
+  candidateMidsFromSet,
+  midBetweenPointAndRect,
+  type Axis,
+} from "./mid"
+import { pathKey, shiftSegmentOrth } from "./pathOps"
+
+type PathKey = string
+
+export class SchematicTraceSingleLineSolver2 extends BaseSolver {
+  pins: MspConnectionPair["pins"]
+  inputProblem: InputProblem
+  chipMap: Record<string, InputChip>
+
+  obstacles: ChipWithBounds[]
+  rectById: Map<string, ChipWithBounds>
+  aabb: { minX: number; maxX: number; minY: number; maxY: number }
+
+  baseElbow: Point[]
+
+  solvedTracePath: Point[] | null = null
+
+  private queue: Array<{ path: Point[]; collisionChipIds: Set<ChipId> }> = []
+  private visited: Set<PathKey> = new Set()
+
+  constructor(params: {
+    pins: MspConnectionPair["pins"]
+    inputProblem: InputProblem
+    chipMap: Record<string, InputChip>
+  }) {
+    super()
+    this.pins = params.pins
+    this.inputProblem = params.inputProblem
+    this.chipMap = params.chipMap
+
+    // Ensure facing directions are present
+    for (const pin of this.pins) {
+      if (!pin._facingDirection) {
+        const chip = this.chipMap[pin.chipId]
+        pin._facingDirection = getPinDirection(pin, chip)
+      }
+    }
+
+    // Build obstacle rects from chips
+    this.obstacles = getObstacleRects(this.inputProblem)
+    this.rectById = new Map(this.obstacles.map((r) => [r.chipId, r]))
+
+    // Build initial elbow path
+    const [pin1, pin2] = this.pins
+    this.baseElbow = calculateElbow(
+      {
+        x: pin1.x,
+        y: pin1.y,
+        facingDirection: pin1._facingDirection!,
+      },
+      {
+        x: pin2.x,
+        y: pin2.y,
+        facingDirection: pin2._facingDirection!,
+      },
+      { overshoot: 0.2 },
+    )
+
+    // Bounds defined by PA and PB
+    this.aabb = aabbFromPoints(
+      { x: pin1.x, y: pin1.y },
+      { x: pin2.x, y: pin2.y },
+    )
+
+    // Seed search
+    this.queue.push({ path: this.baseElbow, collisionChipIds: new Set() })
+    this.visited.add(pathKey(this.baseElbow))
+  }
+
+  override getConstructorParams(): ConstructorParameters<
+    typeof SchematicTraceSingleLineSolver2
+  >[0] {
+    return {
+      chipMap: this.chipMap,
+      pins: this.pins,
+      inputProblem: this.inputProblem,
+    }
+  }
+
+  private axisOfSegment(a: Point, b: Point): Axis | null {
+    if (isVertical(a, b)) return "x"
+    if (isHorizontal(a, b)) return "y"
+    return null
+  }
+
+  private pathLength(pts: Point[]): number {
+    let sum = 0
+    for (let i = 0; i < pts.length - 1; i++) {
+      sum +=
+        Math.abs(pts[i + 1]!.x - pts[i]!.x) +
+        Math.abs(pts[i + 1]!.y - pts[i]!.y)
+    }
+    return sum
+  }
+
+  override _step() {
+    if (this.solvedTracePath) {
+      this.solved = true
+      return
+    }
+
+    const state = this.queue.shift()
+    if (!state) {
+      this.failed = true
+      this.error = "No collision-free path found"
+      return
+    }
+
+    const { path, collisionChipIds } = state
+
+    const collision = findFirstCollision(path, this.obstacles)
+
+    if (!collision) {
+      this.solvedTracePath = path
+      this.solved = true
+      return
+    }
+
+    let { segIndex, rect } = collision
+
+    // Never move the first or last segments - move adjacent segment instead
+    const isFirstSegment = segIndex === 0
+    const isLastSegment = segIndex === path.length - 2
+
+    if (isFirstSegment) {
+      // If first segment collides, move the second segment instead
+      if (path.length < 3) {
+        // Path too short to have an adjacent segment to move
+        return
+      }
+      segIndex = 1
+    } else if (isLastSegment) {
+      // If last segment collides, move the second-to-last segment instead
+      if (path.length < 3) {
+        // Path too short to have an adjacent segment to move
+        return
+      }
+      segIndex = path.length - 3
+    }
+
+    const a = path[segIndex]!
+    const b = path[segIndex + 1]!
+    const axis = this.axisOfSegment(a, b)
+    if (!axis) {
+      // Should not happen for elbow paths
+      return
+    }
+
+    const [PA, PB] = this.pins
+    const candidates: number[] = []
+
+    if (collisionChipIds.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)
+
+      // Combine and deduplicate candidates
+      const allCandidates = [...m1, ...m2]
+      const uniqueCandidates = [...new Set(allCandidates)]
+      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,
+      )
+      candidates.push(...mids)
+    }
+
+    // Generate new shifted paths, order by total path length (shorter first)
+    const newStates: Array<{
+      path: Point[]
+      collisionRectIds: Set<string>
+      len: number
+    }> = []
+
+    for (const coord of candidates) {
+      const newPath = shiftSegmentOrth(path, segIndex, axis, coord)
+      if (!newPath) continue
+      const key = pathKey(newPath)
+      if (this.visited.has(key)) continue
+      this.visited.add(key)
+      const nextSet = new Set(collisionChipIds)
+      nextSet.add(rect.chipId)
+      const len = this.pathLength(newPath)
+      newStates.push({ path: newPath, collisionRectIds: nextSet, len })
+    }
+
+    newStates.sort((a, b) => a.len - b.len)
+    for (const st of newStates) {
+      this.queue.push({ path: st.path, collisionChipIds: st.collisionRectIds })
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const g = visualizeInputProblem(this.inputProblem, {
+      chipAlpha: 0.1,
+      connectionAlpha: 0.1,
+    })
+
+    // Draw all the new candidates
+    for (const { path, collisionChipIds: collisionRectIds } of this.queue) {
+      g.lines!.push({ points: path, strokeColor: "teal", strokeDash: "2 2" })
+    }
+
+    if (this.solvedTracePath) {
+      g.lines!.push({ points: this.solvedTracePath, strokeColor: "green" })
+    } else if (this.queue.length > 0) {
+      // Show next candidate to be explored
+      g.lines!.push({ points: this.queue[0]!.path, strokeColor: "orange" })
+    }
+
+    return g
+  }
+}

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

@@ -0,0 +1,57 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { ChipWithBounds } from "./rect"
+
+const EPS = 1e-9
+
+export const isVertical = (a: Point, b: Point, eps = EPS) =>
+  Math.abs(a.x - b.x) < eps
+export const isHorizontal = (a: Point, b: Point, eps = EPS) =>
+  Math.abs(a.y - b.y) < eps
+
+export const segmentIntersectsRect = (
+  a: Point,
+  b: Point,
+  r: ChipWithBounds,
+  eps = EPS,
+): boolean => {
+  const vert = isVertical(a, b, eps)
+  const horz = isHorizontal(a, b, eps)
+  if (!vert && !horz) return false
+
+  if (vert) {
+    const x = a.x
+    if (x < r.minX - eps || x > r.maxX + eps) return false
+    const segMinY = Math.min(a.y, b.y)
+    const segMaxY = Math.max(a.y, b.y)
+    const overlap = Math.min(segMaxY, r.maxY) - Math.max(segMinY, r.minY)
+    return overlap > eps
+  } else {
+    const y = a.y
+    if (y < r.minY - eps || y > r.maxY + eps) return false
+    const segMinX = Math.min(a.x, b.x)
+    const segMaxX = Math.max(a.x, b.x)
+    const overlap = Math.min(segMaxX, r.maxX) - Math.max(segMinX, r.minX)
+    return overlap > eps
+  }
+}
+
+export const findFirstCollision = (
+  pts: Point[],
+  rects: ChipWithBounds[],
+  opts: {
+    excludeRectIdsForSegment?: (segIndex: number) => Set<string>
+  } = {},
+): { segIndex: number; rect: ChipWithBounds } | 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>()
+    for (const r of rects) {
+      if (excluded.has(r.chipId)) continue
+      if (segmentIntersectsRect(a, b, r)) {
+        return { segIndex: i, rect: r }
+      }
+    }
+  }
+  return null
+}