@tscircuit/schematic-trace-solver 0.0.97 → 0.0.99

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry.ts

@@ -0,0 +1,108 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { RailOrientation, RailSegment } from "./types"
+
+export const RAIL_ALIGNMENT_EPSILON = 2e-3
+
+export const nearlyEqual = (a: number, b: number) =>
+  Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON
+
+export const isHorizontal = (a: Point, b: Point) => nearlyEqual(a.y, b.y)
+
+export const isVertical = (a: Point, b: Point) => nearlyEqual(a.x, b.x)
+
+const isPositiveLength = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON ||
+  Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON
+
+export const getRailOrientation = (
+  a: Point,
+  b: Point,
+): RailOrientation | null => {
+  if (!isPositiveLength(a, b)) return null
+  if (isVertical(a, b)) return "vertical"
+  if (isHorizontal(a, b)) return "horizontal"
+  return null
+}
+
+export const rangesTouchOrOverlap = (a: RailSegment, b: RailSegment) =>
+  Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >=
+  -RAIL_ALIGNMENT_EPSILON
+
+export const pointsEqual = (a: Point, b: Point) =>
+  nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y)
+
+export const getDistinctCoordinates = (coordinates: number[]) => {
+  const distinct: number[] = []
+  for (const coordinate of coordinates) {
+    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
+      distinct.push(coordinate)
+    }
+  }
+  return distinct
+}
+
+interface Interval {
+  coordinate: number
+  min: number
+  max: number
+}
+
+const getMergedIntervalLength = (intervals: Interval[]) => {
+  const groups: Interval[][] = []
+  for (const interval of intervals) {
+    const group = groups.find((items) =>
+      nearlyEqual(items[0]!.coordinate, interval.coordinate),
+    )
+    if (group) group.push(interval)
+    else groups.push([interval])
+  }
+
+  return groups.reduce((total, group) => {
+    const sorted = [...group].sort((a, b) => a.min - b.min)
+    let groupLength = 0
+    let currentMin = sorted[0]!.min
+    let currentMax = sorted[0]!.max
+
+    for (const interval of sorted.slice(1)) {
+      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+        currentMax = Math.max(currentMax, interval.max)
+      } else {
+        groupLength += currentMax - currentMin
+        currentMin = interval.min
+        currentMax = interval.max
+      }
+    }
+
+    return total + groupLength + currentMax - currentMin
+  }, 0)
+}
+
+/** Returns rendered length after overlapping collinear runs are merged. */
+export const getVisibleTraceLength = (traces: SolvedTracePath[]) => {
+  const horizontal: Interval[] = []
+  const vertical: Interval[] = []
+
+  for (const trace of traces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index]!
+      const end = trace.tracePath[index + 1]!
+
+      if (isHorizontal(start, end)) {
+        horizontal.push({
+          coordinate: start.y,
+          min: Math.min(start.x, end.x),
+          max: Math.max(start.x, end.x),
+        })
+      } else if (isVertical(start, end)) {
+        vertical.push({
+          coordinate: start.x,
+          min: Math.min(start.y, end.y),
+          max: Math.max(start.y, end.y),
+        })
+      }
+    }
+  }
+
+  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical)
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getComponentSideRailSegments.ts

@@ -0,0 +1,121 @@
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+import type { InputChip } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import { getRailOrientation, RAIL_ALIGNMENT_EPSILON } from "./geometry"
+import type { RailSegment } from "./types"
+
+type UnassociatedRailSegment = Omit<
+  RailSegment,
+  "componentId" | "componentFacingDirection"
+>
+
+const getMovableRailSegments = (
+  trace: SolvedTracePath,
+): UnassociatedRailSegment[] => {
+  const segments: UnassociatedRailSegment[] = []
+  const path = trace.tracePath
+
+  for (let segmentIndex = 1; segmentIndex < path.length - 2; segmentIndex++) {
+    const previous = path[segmentIndex - 1]!
+    const start = path[segmentIndex]!
+    const end = path[segmentIndex + 1]!
+    const next = path[segmentIndex + 2]!
+    const orientation = getRailOrientation(start, end)
+    if (!orientation) continue
+
+    const previousOrientation = getRailOrientation(previous, start)
+    const nextOrientation = getRailOrientation(end, next)
+    if (!previousOrientation || !nextOrientation) continue
+    if (previousOrientation === orientation || nextOrientation === orientation)
+      continue
+
+    const alongValues =
+      orientation === "vertical" ? [start.y, end.y] : [start.x, end.x]
+    segments.push({
+      traceId: trace.mspPairId,
+      segmentIndex,
+      globalConnNetId: trace.globalConnNetId,
+      orientation,
+      coordinate: orientation === "vertical" ? start.x : start.y,
+      minAlong: Math.min(...alongValues),
+      maxAlong: Math.max(...alongValues),
+    })
+  }
+
+  return segments
+}
+
+const railIsOutsideComponent = (
+  segment: UnassociatedRailSegment,
+  chip: InputChip,
+  facingDirection: FacingDirection,
+) => {
+  const minX = chip.center.x - chip.width / 2
+  const maxX = chip.center.x + chip.width / 2
+  const minY = chip.center.y - chip.height / 2
+  const maxY = chip.center.y + chip.height / 2
+
+  switch (facingDirection) {
+    case "x-":
+      return (
+        segment.orientation === "vertical" &&
+        segment.coordinate <= minX + RAIL_ALIGNMENT_EPSILON
+      )
+    case "x+":
+      return (
+        segment.orientation === "vertical" &&
+        segment.coordinate >= maxX - RAIL_ALIGNMENT_EPSILON
+      )
+    case "y+":
+      return (
+        segment.orientation === "horizontal" &&
+        segment.coordinate >= maxY - RAIL_ALIGNMENT_EPSILON
+      )
+    case "y-":
+      return (
+        segment.orientation === "horizontal" &&
+        segment.coordinate <= minY + RAIL_ALIGNMENT_EPSILON
+      )
+  }
+}
+
+/** Associates each movable internal rail with the nearest component endpoint. */
+export const getComponentSideRailSegments = (
+  trace: SolvedTracePath,
+  chipMap: Map<string, InputChip>,
+): RailSegment[] => {
+  const segments: RailSegment[] = []
+
+  for (const segment of getMovableRailSegments(trace)) {
+    const associations = trace.pins.flatMap((pin, pinIndex) => {
+      const chip = chipMap.get(pin.chipId)
+      if (!chip) return []
+
+      const componentFacingDirection =
+        pin._facingDirection ?? getPinDirection(pin, chip)
+      if (!railIsOutsideComponent(segment, chip, componentFacingDirection)) {
+        return []
+      }
+
+      return [
+        {
+          componentId: chip.chipId,
+          componentFacingDirection,
+          distanceFromEndpoint:
+            pinIndex === 0
+              ? segment.segmentIndex
+              : trace.tracePath.length - 2 - segment.segmentIndex,
+        },
+      ]
+    })
+
+    associations.sort((a, b) => a.distanceFromEndpoint - b.distanceFromEndpoint)
+    const association = associations[0]
+    if (!association) continue
+
+    segments.push({ ...segment, ...association })
+  }
+
+  return segments
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getRailGroups.ts

@@ -0,0 +1,114 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { segmentIntersectsRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import type { ObstacleRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { InputProblem } from "lib/types/InputProblem"
+import { getComponentSideRailSegments } from "./getComponentSideRailSegments"
+import { nearlyEqual, rangesTouchOrOverlap } from "./geometry"
+import type { RailSegment } from "./types"
+
+const getCorridor = (a: RailSegment, b: RailSegment): [Point, Point] => {
+  const overlapMin = Math.max(a.minAlong, b.minAlong)
+  const overlapMax = Math.min(a.maxAlong, b.maxAlong)
+  const along = (overlapMin + overlapMax) / 2
+
+  return a.orientation === "vertical"
+    ? [
+        { x: a.coordinate, y: along },
+        { x: b.coordinate, y: along },
+      ]
+    : [
+        { x: along, y: a.coordinate },
+        { x: along, y: b.coordinate },
+      ]
+}
+
+const corridorIsClear = (
+  a: RailSegment,
+  b: RailSegment,
+  obstacles: ObstacleRect[],
+) => {
+  if (!rangesTouchOrOverlap(a, b)) return true
+  const [start, end] = getCorridor(a, b)
+  return !obstacles.some((obstacle) =>
+    segmentIntersectsRect(start, end, obstacle),
+  )
+}
+
+const tracesSharePin = (
+  a: RailSegment,
+  b: RailSegment,
+  traceMap: Map<string, SolvedTracePath>,
+) => {
+  if (a.traceId === b.traceId) return true
+
+  const aPinIds = new Set(traceMap.get(a.traceId)!.pins.map((pin) => pin.pinId))
+  return traceMap.get(b.traceId)!.pins.some((pin) => aPinIds.has(pin.pinId))
+}
+
+const canJoinRailGroup = (
+  start: RailSegment,
+  current: RailSegment,
+  candidate: RailSegment,
+  traceMap: Map<string, SolvedTracePath>,
+  obstacles: ObstacleRect[],
+) =>
+  candidate.globalConnNetId === start.globalConnNetId &&
+  candidate.orientation === start.orientation &&
+  candidate.componentId === start.componentId &&
+  candidate.componentFacingDirection === start.componentFacingDirection &&
+  (rangesTouchOrOverlap(current, candidate) ||
+    tracesSharePin(current, candidate, traceMap)) &&
+  corridorIsClear(current, candidate, obstacles)
+
+export const getRailGroups = (
+  traces: SolvedTracePath[],
+  eligibleTraceIds: ReadonlySet<string>,
+  inputProblem: InputProblem,
+  obstacles: ObstacleRect[],
+): RailSegment[][] => {
+  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]))
+  const segments = traces
+    .filter((trace) => eligibleTraceIds.has(trace.mspPairId))
+    .flatMap((trace) => getComponentSideRailSegments(trace, chipMap))
+  const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]))
+  const visited = new Set<number>()
+  const groups: RailSegment[][] = []
+
+  for (let startIndex = 0; startIndex < segments.length; startIndex++) {
+    if (visited.has(startIndex)) continue
+
+    const start = segments[startIndex]!
+    const queue = [startIndex]
+    const group: RailSegment[] = []
+    visited.add(startIndex)
+
+    for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+      const current = segments[queue[queueIndex]!]!
+      group.push(current)
+
+      for (
+        let candidateIndex = 0;
+        candidateIndex < segments.length;
+        candidateIndex++
+      ) {
+        if (visited.has(candidateIndex)) continue
+        const candidate = segments[candidateIndex]!
+        if (!canJoinRailGroup(start, current, candidate, traceMap, obstacles)) {
+          continue
+        }
+
+        visited.add(candidateIndex)
+        queue.push(candidateIndex)
+      }
+    }
+
+    const traceCount = new Set(group.map((segment) => segment.traceId)).size
+    const hasDifferentCoordinates = group.some(
+      (segment) => !nearlyEqual(segment.coordinate, group[0]!.coordinate),
+    )
+    if (traceCount >= 2 && hasDifferentCoordinates) groups.push(group)
+  }
+
+  return groups
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts

@@ -0,0 +1,27 @@
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { simplifyPath } from "../simplifyPath"
+import type { RailSegment } from "./types"
+
+export const moveRailSegments = (
+  trace: SolvedTracePath,
+  segments: RailSegment[],
+  coordinate: number,
+): SolvedTracePath => {
+  const pointsToMove = new Set<number>()
+  for (const segment of segments) {
+    pointsToMove.add(segment.segmentIndex)
+    pointsToMove.add(segment.segmentIndex + 1)
+  }
+
+  const orientation = segments[0]!.orientation
+  const tracePath = simplifyPath(
+    trace.tracePath.map((point, index) => {
+      if (!pointsToMove.has(index)) return point
+      return orientation === "vertical"
+        ? { ...point, x: coordinate }
+        : { ...point, y: coordinate }
+    }),
+  )
+
+  return { ...trace, tracePath }
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors.ts

@@ -0,0 +1,30 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+const getAnchoredTraceIds = (
+  label: NetLabelPlacement,
+  traces: SolvedTracePath[],
+) =>
+  new Set(
+    traces
+      .filter(
+        (trace) =>
+          trace.globalConnNetId === label.globalConnNetId &&
+          tracePathContainsPoint(trace.tracePath, label.anchorPoint),
+      )
+      .map((trace) => trace.mspPairId),
+  )
+
+export const preservesLabelAnchors = (
+  labels: NetLabelPlacement[],
+  before: SolvedTracePath[],
+  after: SolvedTracePath[],
+) =>
+  labels.every((label) => {
+    const anchoredBefore = getAnchoredTraceIds(label, before)
+    if (anchoredBefore.size === 0) return true
+
+    const anchoredAfter = getAnchoredTraceIds(label, after)
+    return [...anchoredBefore].every((traceId) => anchoredAfter.has(traceId))
+  })

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/scoreRailAlignment.ts

@@ -0,0 +1,67 @@
+import {
+  countPathIntersections,
+  getPathLength,
+} from "lib/solvers/Example28Solver/geometry"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { countTurns } from "../countTurns"
+import {
+  getVisibleTraceLength,
+  nearlyEqual,
+  RAIL_ALIGNMENT_EPSILON,
+} from "./geometry"
+import type { AlignmentScore, TraceGeometryMetrics } from "./types"
+
+export const countOtherNetCrossings = (
+  traces: SolvedTracePath[],
+  allTraces: SolvedTracePath[],
+) => {
+  let crossings = 0
+  for (const trace of traces) {
+    for (const otherTrace of allTraces) {
+      if (trace.globalConnNetId === otherTrace.globalConnNetId) continue
+      crossings += countPathIntersections(trace.tracePath, otherTrace.tracePath)
+    }
+  }
+  return crossings
+}
+
+export const getTraceGeometryMetrics = (
+  traces: SolvedTracePath[],
+  allTraces: SolvedTracePath[],
+): TraceGeometryMetrics => ({
+  turnCount: traces.reduce(
+    (total, trace) => total + countTurns(trace.tracePath),
+    0,
+  ),
+  visibleLength: getVisibleTraceLength(traces),
+  pathLength: traces.reduce(
+    (sum, trace) => sum + getPathLength(trace.tracePath),
+    0,
+  ),
+  otherNetCrossings: countOtherNetCrossings(traces, allTraces),
+})
+
+export const scoreIsBetter = (
+  candidate: AlignmentScore,
+  best: AlignmentScore,
+) => {
+  if (candidate.turnCount !== best.turnCount)
+    return candidate.turnCount < best.turnCount
+  if (!nearlyEqual(candidate.visibleLength, best.visibleLength))
+    return candidate.visibleLength < best.visibleLength
+  if (!nearlyEqual(candidate.pathLength, best.pathLength))
+    return candidate.pathLength < best.pathLength
+  if (candidate.otherNetCrossings !== best.otherNetCrossings)
+    return candidate.otherNetCrossings < best.otherNetCrossings
+  if (!nearlyEqual(candidate.displacement, best.displacement))
+    return candidate.displacement < best.displacement
+  return candidate.coordinate < best.coordinate
+}
+
+export const isReadabilityImprovement = (
+  candidate: TraceGeometryMetrics,
+  baseline: TraceGeometryMetrics,
+) =>
+  candidate.turnCount <= baseline.turnCount &&
+  (candidate.turnCount < baseline.turnCount ||
+    candidate.visibleLength <= baseline.visibleLength + RAIL_ALIGNMENT_EPSILON)

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/types.ts

@@ -0,0 +1,34 @@
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { FacingDirection } from "lib/utils/dir"
+
+export type RailOrientation = "horizontal" | "vertical"
+
+export interface RailSegment {
+  traceId: string
+  segmentIndex: number
+  globalConnNetId: string
+  orientation: RailOrientation
+  coordinate: number
+  minAlong: number
+  maxAlong: number
+  componentId: string
+  componentFacingDirection: FacingDirection
+}
+
+export interface TraceGeometryMetrics {
+  turnCount: number
+  visibleLength: number
+  pathLength: number
+  otherNetCrossings: number
+}
+
+export interface AlignmentScore extends TraceGeometryMetrics {
+  displacement: number
+  coordinate: number
+}
+
+export interface AlignmentCandidate {
+  traces: SolvedTracePath[]
+  changedTraceIds: string[]
+  score: AlignmentScore
+}

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

@@ -10,6 +10,7 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import { generateRerouteCandidates } from "../../rerouteCollidingTrace"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
 import { detectTraceLabelOverlap } from "../../detectTraceLabelOverlap"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
 
 interface SingleOverlapSolverInput {
   trace: SolvedTracePath
@@ -21,66 +22,6 @@ interface SingleOverlapSolverInput {
 }
 
 const MAX_TRIES = 5
-const COINCIDENT_EPS = 2e-3
-
-/**
- * Returns true if any segment of the path is parallel and coincident
- * (within COINCIDENT_EPS) with a segment of one of the given traces.
- * Perpendicular crossings are allowed.
- */
-const doesPathCoincideWithTraces = (
-  path: Point[],
-  traces: SolvedTracePath[],
-): boolean => {
-  const rangesOverlap1D = (a1: number, a2: number, b1: number, b2: number) =>
-    Math.min(Math.max(a1, a2), Math.max(b1, b2)) -
-      Math.max(Math.min(a1, a2), Math.min(b1, b2)) >
-    COINCIDENT_EPS
-
-  for (let i = 0; i < path.length - 1; i++) {
-    const pathSegStart = path[i]!
-    const pathSegEnd = path[i + 1]!
-    const isVertical = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS
-    const isHorizontal =
-      Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS
-    if (!isVertical && !isHorizontal) continue
-
-    // For a vertical segment, coincidence is measured in x and overlap in y
-    // (and vice versa for horizontal)
-    const crossAxis = isVertical ? "x" : "y"
-    const alongAxis = isVertical ? "y" : "x"
-
-    for (const trace of traces) {
-      for (let j = 0; j < trace.tracePath.length - 1; j++) {
-        const traceSegStart = trace.tracePath[j]!
-        const traceSegEnd = trace.tracePath[j + 1]!
-
-        const isParallel =
-          Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) <
-          COINCIDENT_EPS
-        if (!isParallel) continue
-
-        const isCoincident =
-          Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) <
-          COINCIDENT_EPS
-        if (!isCoincident) continue
-
-        if (
-          rangesOverlap1D(
-            pathSegStart[alongAxis],
-            pathSegEnd[alongAxis],
-            traceSegStart[alongAxis],
-            traceSegEnd[alongAxis],
-          )
-        ) {
-          return true
-        }
-      }
-    }
-  }
-  return false
-}
-
 /**
  * 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

package/lib/utils/doesPathCoincideWithTraces.ts

@@ -0,0 +1,61 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+
+const COINCIDENT_EPS = 2e-3
+
+/**
+ * Returns true when an orthogonal path shares a positive-length segment with
+ * an existing trace. Perpendicular crossings and point-only contact are
+ * intentionally allowed.
+ */
+export const doesPathCoincideWithTraces = (
+  path: Point[],
+  traces: SolvedTracePath[],
+): boolean => {
+  const rangesOverlap1D = (a1: number, a2: number, b1: number, b2: number) =>
+    Math.min(Math.max(a1, a2), Math.max(b1, b2)) -
+      Math.max(Math.min(a1, a2), Math.min(b1, b2)) >
+    COINCIDENT_EPS
+
+  for (let i = 0; i < path.length - 1; i++) {
+    const pathSegStart = path[i]!
+    const pathSegEnd = path[i + 1]!
+    const isVertical = Math.abs(pathSegStart.x - pathSegEnd.x) < COINCIDENT_EPS
+    const isHorizontal =
+      Math.abs(pathSegStart.y - pathSegEnd.y) < COINCIDENT_EPS
+    if (!isVertical && !isHorizontal) continue
+
+    const crossAxis = isVertical ? "x" : "y"
+    const alongAxis = isVertical ? "y" : "x"
+
+    for (const trace of traces) {
+      for (let j = 0; j < trace.tracePath.length - 1; j++) {
+        const traceSegStart = trace.tracePath[j]!
+        const traceSegEnd = trace.tracePath[j + 1]!
+
+        const isParallel =
+          Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) <
+          COINCIDENT_EPS
+        if (!isParallel) continue
+
+        const isCoincident =
+          Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) <
+          COINCIDENT_EPS
+        if (!isCoincident) continue
+
+        if (
+          rangesOverlap1D(
+            pathSegStart[alongAxis],
+            pathSegEnd[alongAxis],
+            traceSegStart[alongAxis],
+            traceSegEnd[alongAxis],
+          )
+        ) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}

package/package.json

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