@tscircuit/fanout-solver 0.0.19 → 0.0.21

package/README.md

@@ -239,10 +239,16 @@ samples in parallel, and `--sample-timeout-seconds 600` prevents a difficult
 sample from blocking the remaining work. Each run writes the full ordered
 results to `benchmark-results/srj29.json` and
 `benchmark-results/srj29.md`. A row is marked solved only when every input
-connection has a validated breakout, all downstream endpoints remain attached,
-and the independent DRC audit passes. Partial solutions are reported as
-benchmark results instead of failing the command, making current completion
-rates a baseline for solver improvements. `bun run benchmark:srj29` is an alias
+connection has a validated breakout and an independent physical-copper audit
+proves that the emitted wires, vias, and same-net pads connect every original
+endpoint on compatible layers. A second independent audit checks every emitted
+trace and via against different-net pads, obstacles, traces, and vias on every
+physical layer in its span. Reaching an arbitrary boundary point, retaining an
+unrouted endpoint in the output JSON, or emitting copper with a DRC violation
+does not count. The report separates fanout-prefix completion from physically
+connected original connections so partial progress remains visible without
+overstating it as a solution. Partial solutions are reported as benchmark
+results instead of failing the command. `bun run benchmark:srj29` is an alias
 for the same command.
 
 The `SRJ29 Benchmark` GitHub Actions workflow runs the complete dataset on a

package/lib/index.ts

@@ -1,7 +1,18 @@
 export { FanoutSolver } from "./fanout-solver"
 export { getCopperLayerColor } from "./layer-colors"
 export { getCopperLayerNames } from "./layer-names"
+export { validateOriginalEndpointConnectivity } from "./validate-original-endpoint-connectivity"
+export { validateRoutedCopperDrc } from "./validate-routed-copper-drc"
 export { validateFanoutSolution } from "./validate-fanout-solution"
+export type {
+  OriginalEndpointConnectivityIssue,
+  OriginalEndpointConnectivityReport,
+} from "./validate-original-endpoint-connectivity"
+export type {
+  RoutedCopperDrcIssue,
+  RoutedCopperDrcIssueCode,
+  RoutedCopperDrcReport,
+} from "./validate-routed-copper-drc"
 export type {
   Bounds,
   FanoutAttemptSummary,

package/lib/validate-original-endpoint-connectivity.ts

@@ -0,0 +1,374 @@
+import type {
+  ConnectionPoint,
+  Obstacle,
+  SimpleRouteConnection,
+  SimpleRouteJson,
+  SimplifiedPcbTrace,
+} from "@tscircuit/capacity-autorouter"
+import {
+  distance,
+  distancePointToObstacle,
+  distancePointToSegment,
+  distanceSegmentToObstacle,
+  distanceSegmentToSegment,
+  pointIsInsideObstacle,
+} from "./geometry"
+import { getCopperLayerNames, getLayerSpan } from "./layer-names"
+import {
+  connectionsShareElectricalNet,
+  getConnectionNetKey,
+  obstacleSharesElectricalNet,
+} from "./net-identity"
+import type { Point2D, RoutedSegment } from "./types"
+
+const EPSILON = 1e-6
+
+export interface OriginalEndpointConnectivityIssue {
+  code: "original-endpoints-disconnected"
+  connectionName: string
+  disconnectedEndpointIndices: number[]
+  message: string
+}
+
+export interface OriginalEndpointConnectivityReport {
+  valid: boolean
+  checkedConnectionCount: number
+  connectedConnectionCount: number
+  checkedEndpointCount: number
+  connectedEndpointCount: number
+  issues: OriginalEndpointConnectivityIssue[]
+}
+
+interface EndpointCopper {
+  type: "endpoint"
+  connectionName: string
+  endpointIndex: number
+  point: ConnectionPoint
+  layers: string[]
+}
+
+interface ObstacleCopper {
+  type: "obstacle"
+  obstacle: Obstacle
+}
+
+interface SegmentCopper {
+  type: "segment"
+  segment: RoutedSegment
+}
+
+interface ViaCopper {
+  type: "via"
+  center: Point2D
+  diameter: number
+  layers: string[]
+}
+
+type CopperPrimitive =
+  | EndpointCopper
+  | ObstacleCopper
+  | SegmentCopper
+  | ViaCopper
+
+function getPointLayers(point: ConnectionPoint): string[] {
+  return "layer" in point ? [point.layer] : point.layers
+}
+
+function layersOverlap(first: readonly string[], second: readonly string[]) {
+  return first.some((layer) => second.includes(layer))
+}
+
+function extractTraceCopper(
+  trace: SimplifiedPcbTrace,
+  layerNames: string[],
+): Array<SegmentCopper | ViaCopper> {
+  const copper: Array<SegmentCopper | ViaCopper> = []
+  let previousWire:
+    | Extract<SimplifiedPcbTrace["route"][number], { route_type: "wire" }>
+    | undefined
+
+  for (const routePoint of trace.route) {
+    if (routePoint.route_type === "via") {
+      copper.push({
+        type: "via",
+        center: { x: routePoint.x, y: routePoint.y },
+        diameter: routePoint.via_diameter ?? 0,
+        layers: getLayerSpan(
+          routePoint.from_layer,
+          routePoint.to_layer,
+          layerNames,
+        ),
+      })
+      previousWire = undefined
+      continue
+    }
+    if (routePoint.route_type !== "wire") continue
+    if (
+      previousWire &&
+      previousWire.layer === routePoint.layer &&
+      distance(previousWire, routePoint) > EPSILON
+    ) {
+      copper.push({
+        type: "segment",
+        segment: {
+          start: { x: previousWire.x, y: previousWire.y },
+          end: { x: routePoint.x, y: routePoint.y },
+          width: routePoint.width,
+          layer: routePoint.layer,
+        },
+      })
+    }
+    previousWire = routePoint
+  }
+  return copper
+}
+
+function primitivesTouch(first: CopperPrimitive, second: CopperPrimitive) {
+  if (first.type === "endpoint" && second.type === "endpoint") {
+    return (
+      layersOverlap(first.layers, second.layers) &&
+      distance(first.point, second.point) <= EPSILON
+    )
+  }
+  if (first.type === "endpoint" && second.type === "obstacle") {
+    return (
+      layersOverlap(first.layers, second.obstacle.layers) &&
+      pointIsInsideObstacle(first.point, second.obstacle, EPSILON)
+    )
+  }
+  if (first.type === "obstacle" && second.type === "endpoint") {
+    return primitivesTouch(second, first)
+  }
+  if (first.type === "endpoint" && second.type === "segment") {
+    return (
+      first.layers.includes(second.segment.layer) &&
+      distancePointToSegment(
+        first.point,
+        second.segment.start,
+        second.segment.end,
+      ) <=
+        second.segment.width / 2 + EPSILON
+    )
+  }
+  if (first.type === "segment" && second.type === "endpoint") {
+    return primitivesTouch(second, first)
+  }
+  if (first.type === "endpoint" && second.type === "via") {
+    return (
+      layersOverlap(first.layers, second.layers) &&
+      distance(first.point, second.center) <= second.diameter / 2 + EPSILON
+    )
+  }
+  if (first.type === "via" && second.type === "endpoint") {
+    return primitivesTouch(second, first)
+  }
+  if (first.type === "obstacle" && second.type === "segment") {
+    return (
+      first.obstacle.layers.includes(second.segment.layer) &&
+      distanceSegmentToObstacle(second.segment, first.obstacle) <=
+        second.segment.width / 2 + EPSILON
+    )
+  }
+  if (first.type === "segment" && second.type === "obstacle") {
+    return primitivesTouch(second, first)
+  }
+  if (first.type === "obstacle" && second.type === "via") {
+    return (
+      layersOverlap(first.obstacle.layers, second.layers) &&
+      distancePointToObstacle(second.center, first.obstacle) <=
+        second.diameter / 2 + EPSILON
+    )
+  }
+  if (first.type === "via" && second.type === "obstacle") {
+    return primitivesTouch(second, first)
+  }
+  if (first.type === "segment" && second.type === "segment") {
+    return (
+      first.segment.layer === second.segment.layer &&
+      distanceSegmentToSegment(
+        first.segment.start,
+        first.segment.end,
+        second.segment.start,
+        second.segment.end,
+      ) <=
+        (first.segment.width + second.segment.width) / 2 + EPSILON
+    )
+  }
+  if (first.type === "segment" && second.type === "via") {
+    return (
+      second.layers.includes(first.segment.layer) &&
+      distancePointToSegment(
+        second.center,
+        first.segment.start,
+        first.segment.end,
+      ) <=
+        second.diameter / 2 + first.segment.width / 2 + EPSILON
+    )
+  }
+  if (first.type === "via" && second.type === "segment") {
+    return primitivesTouch(second, first)
+  }
+  if (first.type === "via" && second.type === "via") {
+    return (
+      layersOverlap(first.layers, second.layers) &&
+      distance(first.center, second.center) <=
+        (first.diameter + second.diameter) / 2 + EPSILON
+    )
+  }
+  return false
+}
+
+class DisjointSet {
+  private readonly parent: number[]
+
+  constructor(size: number) {
+    this.parent = Array.from({ length: size }, (_, index) => index)
+  }
+
+  find(index: number): number {
+    const parent = this.parent[index]!
+    if (parent === index) return index
+    const root = this.find(parent)
+    this.parent[index] = root
+    return root
+  }
+
+  union(first: number, second: number): void {
+    const firstRoot = this.find(first)
+    const secondRoot = this.find(second)
+    if (firstRoot !== secondRoot) this.parent[secondRoot] = firstRoot
+  }
+}
+
+function traceBelongsToNet(
+  inputSrj: SimpleRouteJson,
+  trace: SimplifiedPcbTrace,
+  representativeConnection: SimpleRouteConnection,
+): boolean {
+  return Boolean(
+    trace.connection_name &&
+      connectionsShareElectricalNet(
+        inputSrj,
+        trace.connection_name,
+        representativeConnection.name,
+      ),
+  )
+}
+
+/**
+ * Independently proves that emitted copper connects every original SRJ
+ * endpoint. Merely reaching a boundary or retaining an endpoint in the output
+ * connection metadata does not count as connectivity.
+ */
+export function validateOriginalEndpointConnectivity(params: {
+  inputSrj: SimpleRouteJson
+  routedSrj: SimpleRouteJson
+}): OriginalEndpointConnectivityReport {
+  const { inputSrj, routedSrj } = params
+  const layerNames = getCopperLayerNames(routedSrj.layerCount)
+  const connectionsByNet = new Map<string, SimpleRouteConnection[]>()
+  for (const connection of inputSrj.connections) {
+    const netKey = getConnectionNetKey(connection)
+    const connections = connectionsByNet.get(netKey) ?? []
+    connections.push(connection)
+    connectionsByNet.set(netKey, connections)
+  }
+
+  const issues: OriginalEndpointConnectivityIssue[] = []
+  let connectedConnectionCount = 0
+  let connectedEndpointCount = 0
+
+  for (const connections of connectionsByNet.values()) {
+    const representativeConnection = connections[0]!
+    const endpointCopper: EndpointCopper[] = connections.flatMap((connection) =>
+      connection.pointsToConnect.map((point, endpointIndex) => ({
+        type: "endpoint" as const,
+        connectionName: connection.name,
+        endpointIndex,
+        point,
+        layers: getPointLayers(point),
+      })),
+    )
+    const obstacleCopper: ObstacleCopper[] = inputSrj.obstacles
+      .filter((obstacle) =>
+        obstacleSharesElectricalNet(
+          inputSrj,
+          obstacle,
+          representativeConnection.name,
+        ),
+      )
+      .map((obstacle) => ({ type: "obstacle", obstacle }))
+    const routeCopper = (routedSrj.traces ?? [])
+      .filter((trace) =>
+        traceBelongsToNet(inputSrj, trace, representativeConnection),
+      )
+      .flatMap((trace) => extractTraceCopper(trace, layerNames))
+    const copper: CopperPrimitive[] = [
+      ...endpointCopper,
+      ...obstacleCopper,
+      ...routeCopper,
+    ]
+    const connectedCopper = new DisjointSet(copper.length)
+    for (let firstIndex = 0; firstIndex < copper.length; firstIndex++) {
+      for (
+        let secondIndex = firstIndex + 1;
+        secondIndex < copper.length;
+        secondIndex++
+      ) {
+        if (primitivesTouch(copper[firstIndex]!, copper[secondIndex]!)) {
+          connectedCopper.union(firstIndex, secondIndex)
+        }
+      }
+    }
+
+    const endpointIndexByConnection = new Map<string, number[]>()
+    for (let index = 0; index < endpointCopper.length; index++) {
+      const endpoint = endpointCopper[index]!
+      const indices =
+        endpointIndexByConnection.get(endpoint.connectionName) ?? []
+      indices[endpoint.endpointIndex] = index
+      endpointIndexByConnection.set(endpoint.connectionName, indices)
+    }
+    for (const connection of connections) {
+      const endpointIndices =
+        endpointIndexByConnection.get(connection.name) ?? []
+      const firstEndpointIndex = endpointIndices[0]
+      const firstRoot =
+        firstEndpointIndex === undefined
+          ? undefined
+          : connectedCopper.find(firstEndpointIndex)
+      const disconnectedEndpointIndices = endpointIndices.flatMap(
+        (endpointIndex, index) =>
+          firstRoot === undefined ||
+          connectedCopper.find(endpointIndex) !== firstRoot
+            ? [index]
+            : [],
+      )
+      connectedEndpointCount +=
+        endpointIndices.length - disconnectedEndpointIndices.length
+      if (disconnectedEndpointIndices.length === 0) {
+        connectedConnectionCount++
+      } else {
+        issues.push({
+          code: "original-endpoints-disconnected",
+          connectionName: connection.name,
+          disconnectedEndpointIndices,
+          message: `Connection ${connection.name} has no physical copper path from endpoint 0 to original endpoint${disconnectedEndpointIndices.length === 1 ? "" : "s"} ${disconnectedEndpointIndices.join(", ")}`,
+        })
+      }
+    }
+  }
+
+  const checkedEndpointCount = inputSrj.connections.reduce(
+    (count, connection) => count + connection.pointsToConnect.length,
+    0,
+  )
+  return {
+    valid: issues.length === 0,
+    checkedConnectionCount: inputSrj.connections.length,
+    connectedConnectionCount,
+    checkedEndpointCount,
+    connectedEndpointCount,
+    issues,
+  }
+}

package/lib/validate-routed-copper-drc.ts

@@ -0,0 +1,442 @@
+import type {
+  SimpleRouteJson,
+  SimplifiedPcbTrace,
+} from "@tscircuit/capacity-autorouter"
+import {
+  distance,
+  distancePointToObstacle,
+  distancePointToSegment,
+  distanceSegmentToObstacle,
+  pointIsInsideObstacle,
+  segmentsAreClear,
+} from "./geometry"
+import { getCopperLayerNames, getLayerSpan } from "./layer-names"
+import {
+  connectionsShareElectricalNet,
+  obstacleSharesElectricalNet,
+} from "./net-identity"
+import type { Point2D, RoutedSegment } from "./types"
+
+const EPSILON = 1e-6
+
+export type RoutedCopperDrcIssueCode =
+  | "unknown-trace-connection"
+  | "unsupported-route-point"
+  | "disconnected-trace"
+  | "trace-obstacle-clearance"
+  | "via-obstacle-clearance"
+  | "different-net-trace-clearance"
+  | "different-net-trace-via-clearance"
+  | "different-net-via-clearance"
+
+export interface RoutedCopperDrcIssue {
+  code: RoutedCopperDrcIssueCode
+  message: string
+  traceId: string
+  connectionName?: string
+  otherTraceId?: string
+  otherConnectionName?: string
+  layer?: string
+  obstacleId?: string
+}
+
+export interface RoutedCopperDrcReport {
+  valid: boolean
+  checkedTraceCount: number
+  checkedSegmentCount: number
+  checkedViaCount: number
+  issues: RoutedCopperDrcIssue[]
+}
+
+interface RoutedVia {
+  center: Point2D
+  diameter: number
+  spanLayers: string[]
+}
+
+interface TraceCopper {
+  trace: SimplifiedPcbTrace
+  connectionName: string
+  segments: RoutedSegment[]
+  vias: RoutedVia[]
+}
+
+function isLegalTerminalBodyEscape(params: {
+  inputSrj: SimpleRouteJson
+  segment: RoutedSegment
+  bodyObstacle: SimpleRouteJson["obstacles"][number]
+  connectionName: string
+}): boolean {
+  const { inputSrj, segment, bodyObstacle, connectionName } = params
+  if (bodyObstacle.connectedTo.length > 0 || !bodyObstacle.componentId) {
+    return false
+  }
+  const sameNetComponentPads = inputSrj.obstacles.filter(
+    (obstacle) =>
+      obstacle.componentId === bodyObstacle.componentId &&
+      obstacle.layers.includes(segment.layer) &&
+      obstacleSharesElectricalNet(inputSrj, obstacle, connectionName),
+  )
+  for (const pad of sameNetComponentPads) {
+    for (const [terminal, other] of [
+      [segment.start, segment.end],
+      [segment.end, segment.start],
+    ] as const) {
+      if (!pointIsInsideObstacle(terminal, pad, EPSILON)) continue
+      const outwardFromBody = {
+        x: terminal.x - bodyObstacle.center.x,
+        y: terminal.y - bodyObstacle.center.y,
+      }
+      const terminalToOther = {
+        x: other.x - terminal.x,
+        y: other.y - terminal.y,
+      }
+      if (
+        outwardFromBody.x * terminalToOther.x +
+          outwardFromBody.y * terminalToOther.y >
+        EPSILON
+      ) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+function pointsMatch(first: Point2D, second: Point2D): boolean {
+  return distance(first, second) <= EPSILON
+}
+
+function addIssue(
+  issues: RoutedCopperDrcIssue[],
+  issue: RoutedCopperDrcIssue,
+): void {
+  issues.push(issue)
+}
+
+function extractTraceCopper(params: {
+  srj: SimpleRouteJson
+  trace: SimplifiedPcbTrace
+  connectionName: string
+  layerNames: string[]
+  issues: RoutedCopperDrcIssue[]
+}): TraceCopper {
+  const { srj, trace, connectionName, layerNames, issues } = params
+  const segments: RoutedSegment[] = []
+  const vias: RoutedVia[] = []
+  let previousWire:
+    | Extract<SimplifiedPcbTrace["route"][number], { route_type: "wire" }>
+    | undefined
+  let pendingVia:
+    | Extract<SimplifiedPcbTrace["route"][number], { route_type: "via" }>
+    | undefined
+
+  for (const routePoint of trace.route) {
+    if (routePoint.route_type === "via") {
+      const spanLayers = getLayerSpan(
+        routePoint.from_layer,
+        routePoint.to_layer,
+        layerNames,
+      )
+      vias.push({
+        center: { x: routePoint.x, y: routePoint.y },
+        diameter:
+          routePoint.via_diameter ?? srj.minViaPadDiameter ?? srj.minTraceWidth,
+        spanLayers,
+      })
+      if (
+        !previousWire ||
+        !pointsMatch(previousWire, routePoint) ||
+        previousWire.layer !== routePoint.from_layer
+      ) {
+        addIssue(issues, {
+          code: "disconnected-trace",
+          traceId: trace.pcb_trace_id,
+          connectionName,
+          message: `Trace ${trace.pcb_trace_id} reaches a via without a matching ${routePoint.from_layer} wire endpoint`,
+        })
+      }
+      pendingVia = routePoint
+      continue
+    }
+
+    if (routePoint.route_type !== "wire") {
+      addIssue(issues, {
+        code: "unsupported-route-point",
+        traceId: trace.pcb_trace_id,
+        connectionName,
+        message: `Trace ${trace.pcb_trace_id} contains unsupported ${routePoint.route_type} geometry`,
+      })
+      previousWire = undefined
+      pendingVia = undefined
+      continue
+    }
+
+    if (pendingVia) {
+      if (
+        !pointsMatch(routePoint, pendingVia) ||
+        routePoint.layer !== pendingVia.to_layer
+      ) {
+        addIssue(issues, {
+          code: "disconnected-trace",
+          traceId: trace.pcb_trace_id,
+          connectionName,
+          message: `Trace ${trace.pcb_trace_id} does not continue from its via on ${pendingVia.to_layer}`,
+        })
+      }
+      previousWire = routePoint
+      pendingVia = undefined
+      continue
+    }
+
+    if (previousWire) {
+      if (previousWire.layer !== routePoint.layer) {
+        addIssue(issues, {
+          code: "disconnected-trace",
+          traceId: trace.pcb_trace_id,
+          connectionName,
+          message: `Trace ${trace.pcb_trace_id} changes from ${previousWire.layer} to ${routePoint.layer} without a via`,
+        })
+      } else if (!pointsMatch(previousWire, routePoint)) {
+        segments.push({
+          start: { x: previousWire.x, y: previousWire.y },
+          end: { x: routePoint.x, y: routePoint.y },
+          width: routePoint.width,
+          layer: routePoint.layer,
+        })
+      }
+    }
+    previousWire = routePoint
+  }
+
+  if (pendingVia) {
+    addIssue(issues, {
+      code: "disconnected-trace",
+      traceId: trace.pcb_trace_id,
+      connectionName,
+      message: `Trace ${trace.pcb_trace_id} ends at a via without a wire on ${pendingVia.to_layer}`,
+    })
+  }
+
+  return { trace, connectionName, segments, vias }
+}
+
+/**
+ * Independently audits every emitted trace and via against the original SRJ
+ * obstacle field and every other emitted net. This deliberately does not rely
+ * on the solver's accepted route-plan objects.
+ */
+export function validateRoutedCopperDrc(params: {
+  inputSrj: SimpleRouteJson
+  routedSrj: SimpleRouteJson
+  clearance: number
+}): RoutedCopperDrcReport {
+  const { inputSrj, routedSrj, clearance } = params
+  const issues: RoutedCopperDrcIssue[] = []
+  const layerNames = getCopperLayerNames(routedSrj.layerCount)
+  const traceCopper: TraceCopper[] = []
+
+  for (const trace of routedSrj.traces ?? []) {
+    const connectionName = trace.connection_name
+    if (
+      !connectionName ||
+      !inputSrj.connections.some(
+        (connection) => connection.name === connectionName,
+      )
+    ) {
+      addIssue(issues, {
+        code: "unknown-trace-connection",
+        traceId: trace.pcb_trace_id,
+        ...(connectionName ? { connectionName } : {}),
+        message: `Trace ${trace.pcb_trace_id} does not identify an input connection`,
+      })
+      continue
+    }
+    traceCopper.push(
+      extractTraceCopper({
+        srj: routedSrj,
+        trace,
+        connectionName,
+        layerNames,
+        issues,
+      }),
+    )
+  }
+
+  for (const copper of traceCopper) {
+    for (const segment of copper.segments) {
+      for (const obstacle of inputSrj.obstacles) {
+        if (
+          !obstacle.layers.includes(segment.layer) ||
+          obstacleSharesElectricalNet(inputSrj, obstacle, copper.connectionName)
+        ) {
+          continue
+        }
+        if (
+          isLegalTerminalBodyEscape({
+            inputSrj,
+            segment,
+            bodyObstacle: obstacle,
+            connectionName: copper.connectionName,
+          })
+        ) {
+          continue
+        }
+        const actual = distanceSegmentToObstacle(segment, obstacle)
+        const required = segment.width / 2 + clearance
+        if (actual < required - EPSILON) {
+          addIssue(issues, {
+            code: "trace-obstacle-clearance",
+            traceId: copper.trace.pcb_trace_id,
+            connectionName: copper.connectionName,
+            layer: segment.layer,
+            obstacleId: obstacle.obstacleId,
+            message: `Trace ${copper.trace.pcb_trace_id} on ${segment.layer} is ${actual.toFixed(4)}mm from different-net obstacle ${obstacle.obstacleId}; ${required.toFixed(4)}mm is required`,
+          })
+        }
+      }
+    }
+    for (const via of copper.vias) {
+      for (const obstacle of inputSrj.obstacles) {
+        if (
+          !obstacle.layers.some((layer) => via.spanLayers.includes(layer)) ||
+          obstacleSharesElectricalNet(inputSrj, obstacle, copper.connectionName)
+        ) {
+          continue
+        }
+        const actual = distancePointToObstacle(via.center, obstacle)
+        const required = via.diameter / 2 + clearance
+        if (actual < required - EPSILON) {
+          addIssue(issues, {
+            code: "via-obstacle-clearance",
+            traceId: copper.trace.pcb_trace_id,
+            connectionName: copper.connectionName,
+            obstacleId: obstacle.obstacleId,
+            message: `Via in ${copper.trace.pcb_trace_id} is ${actual.toFixed(4)}mm from different-net obstacle ${obstacle.obstacleId} on its layer span; ${required.toFixed(4)}mm is required`,
+          })
+        }
+      }
+    }
+  }
+
+  for (let firstIndex = 0; firstIndex < traceCopper.length; firstIndex++) {
+    const first = traceCopper[firstIndex]!
+    for (
+      let secondIndex = firstIndex + 1;
+      secondIndex < traceCopper.length;
+      secondIndex++
+    ) {
+      const second = traceCopper[secondIndex]!
+      if (
+        connectionsShareElectricalNet(
+          inputSrj,
+          first.connectionName,
+          second.connectionName,
+        )
+      ) {
+        continue
+      }
+
+      for (const firstSegment of first.segments) {
+        for (const secondSegment of second.segments) {
+          if (segmentsAreClear(firstSegment, secondSegment, clearance)) continue
+          addIssue(issues, {
+            code: "different-net-trace-clearance",
+            traceId: first.trace.pcb_trace_id,
+            connectionName: first.connectionName,
+            otherTraceId: second.trace.pcb_trace_id,
+            otherConnectionName: second.connectionName,
+            layer: firstSegment.layer,
+            message: `Different-net traces ${first.trace.pcb_trace_id} and ${second.trace.pcb_trace_id} intersect or violate clearance on ${firstSegment.layer}`,
+          })
+        }
+        for (const secondVia of second.vias) {
+          if (
+            !secondVia.spanLayers.includes(firstSegment.layer) ||
+            distancePointToSegment(
+              secondVia.center,
+              firstSegment.start,
+              firstSegment.end,
+            ) >=
+              secondVia.diameter / 2 +
+                firstSegment.width / 2 +
+                clearance -
+                EPSILON
+          ) {
+            continue
+          }
+          addIssue(issues, {
+            code: "different-net-trace-via-clearance",
+            traceId: first.trace.pcb_trace_id,
+            connectionName: first.connectionName,
+            otherTraceId: second.trace.pcb_trace_id,
+            otherConnectionName: second.connectionName,
+            layer: firstSegment.layer,
+            message: `Trace ${first.trace.pcb_trace_id} violates via clearance to ${second.trace.pcb_trace_id} on ${firstSegment.layer}`,
+          })
+        }
+      }
+
+      for (const firstVia of first.vias) {
+        for (const secondSegment of second.segments) {
+          if (
+            !firstVia.spanLayers.includes(secondSegment.layer) ||
+            distancePointToSegment(
+              firstVia.center,
+              secondSegment.start,
+              secondSegment.end,
+            ) >=
+              firstVia.diameter / 2 +
+                secondSegment.width / 2 +
+                clearance -
+                EPSILON
+          ) {
+            continue
+          }
+          addIssue(issues, {
+            code: "different-net-trace-via-clearance",
+            traceId: first.trace.pcb_trace_id,
+            connectionName: first.connectionName,
+            otherTraceId: second.trace.pcb_trace_id,
+            otherConnectionName: second.connectionName,
+            layer: secondSegment.layer,
+            message: `Via in ${first.trace.pcb_trace_id} violates trace clearance to ${second.trace.pcb_trace_id} on ${secondSegment.layer}`,
+          })
+        }
+        for (const secondVia of second.vias) {
+          if (
+            !firstVia.spanLayers.some((layer) =>
+              secondVia.spanLayers.includes(layer),
+            ) ||
+            distance(firstVia.center, secondVia.center) >=
+              (firstVia.diameter + secondVia.diameter) / 2 + clearance - EPSILON
+          ) {
+            continue
+          }
+          addIssue(issues, {
+            code: "different-net-via-clearance",
+            traceId: first.trace.pcb_trace_id,
+            connectionName: first.connectionName,
+            otherTraceId: second.trace.pcb_trace_id,
+            otherConnectionName: second.connectionName,
+            message: `Different-net vias in ${first.trace.pcb_trace_id} and ${second.trace.pcb_trace_id} violate clearance on an overlapping layer span`,
+          })
+        }
+      }
+    }
+  }
+
+  return {
+    valid: issues.length === 0,
+    checkedTraceCount: routedSrj.traces?.length ?? 0,
+    checkedSegmentCount: traceCopper.reduce(
+      (count, copper) => count + copper.segments.length,
+      0,
+    ),
+    checkedViaCount: traceCopper.reduce(
+      (count, copper) => count + copper.vias.length,
+      0,
+    ),
+    issues,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fanout-solver",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",