@tscircuit/fanout-solver 0.0.18 → 0.0.19

package/README.md

@@ -42,6 +42,11 @@ and treats each bus-layer decision atomically.
   alternate instead of favoring one axis; square grids distribute equally
   across north, south, east, and west.
 - Enumerates combinations of the copper layers implied by `layerCount`.
+- Keeps a bounded beam of route alternatives for multi-connection buses, so
+  grouped power/signal lanes can backtrack across layer and track choices
+  before committing a prefix.
+- Keys route-prefix caches by both bus and layer, preserving plan uniqueness
+  when grouped-layer search changes bus order.
 - Prefers depth-cycled layer assignments: matching north/south (or east/west)
   bus depths share a layer, and deeper pairs cycle through every available
   escape layer. This forces a small stackup to reuse routing channels.
@@ -61,9 +66,17 @@ and treats each bus-layer decision atomically.
   breakout corridor.
 - Chamfers orthogonal routing corners into 45° segments before validating and
   emitting the fanout.
-- Verifies pad, via, trace, and already-routed fanout clearance.
-- Treats an obstacle whose `connectedTo` list contains the connection name as
-  electrically connected copper rather than a foreign keepout.
+- Verifies oriented-pad, via, trace, and already-routed fanout clearance on
+  every complete candidate, independent of the routing strategy that produced
+  it.
+- Resolves `netConnectionName`, connection, port, trace, and obstacle metadata
+  into electrical-net identities. Same-net copper may merge; different-net
+  pads, traces, and vias must retain clearance on every layer they occupy.
+- `allowSameNetMerges` lets grouped branches such as VCC or GND reuse connected
+  copper instead of reserving artificial clearance from one another. It is
+  opt-in; different electrical nets remain hard obstacles.
+- Audits route continuity, unique connection coverage, boundary exits, and
+  retained downstream endpoints before marking a solution complete.
 - Emits supplied fanout traces, via obstacles, and moved breakout endpoints in a
   new `SimpleRouteJson`. The returned problem is ready for a downstream
   autorouter to finish.
@@ -177,6 +190,8 @@ bus-layer combination search.
 - `busLayerAssignments`: the selected layer for every bus
 - `busDirections`: the direction shared by each bus
 - `attempts`: score and success metadata for every tried layer combination
+- `validation`: the final geometry/connectivity report, including the number of
+  independently validated breakouts
 
 ## Dataset 01
 
@@ -198,15 +213,18 @@ parameters. Each sample has one shared boundary around all of its footprints,
 and component bounds come from the exact footprinter-generated copper pad
 extents.
 
-## SRJ19 benchmark
+## SRJ29 benchmark
 
-The repository also loads all 200 samples from
-[`tscircuit/dataset-srj19`](https://github.com/tscircuit/dataset-srj19) as a
-pinned development dependency. The adapter keeps the complete obstacle field
-but selects only connections that touch the BGA, producing progressively larger
-fanout problems with opposite-side passive overlays. Every adapted problem uses
-the same six-layer stackup (`top`, `inner1` through `inner4`, and `bottom`) so
-benchmark improvements are directly comparable.
+The repository loads all 200 samples from the derivative
+[`tscircuit/dataset-srj29-bga-decoupling`](https://github.com/tscircuit/dataset-srj29-bga-decoupling)
+as a pinned development dependency. The adapter keeps the complete obstacle
+field, including opposite-layer capacitor pads and bodies. VCC and GND are
+grouped onto opposite boundary corridors, while the capacitor pad remains the
+downstream endpoint of every power connection; a local capacitor or plane via
+alone cannot count as a solved BGA pin. Remaining edge signals are grouped by
+direction. Every adapted problem uses the same six-layer stackup (`top`,
+`inner1` through `inner4`, and `bottom`) so benchmark improvements are directly
+comparable.
 
 Run the full benchmark with:
 
@@ -219,22 +237,23 @@ Use `--sample sample001`, `--limit 10`, or
 default and print progress as they finish. `--concurrency 8` runs isolated
 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/srj19.json` and
-`benchmark-results/srj19.md`. Partial solutions are reported as benchmark
-results instead of failing the command, making current completion rates a
-baseline for solver improvements. `bun run benchmark:srj19` is an alias for the
-same command.
-
-The `SRJ19 Benchmark` GitHub Actions workflow runs the complete dataset on a
+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
+for the same command.
+
+The `SRJ29 Benchmark` GitHub Actions workflow runs the complete dataset on a
 Blacksmith 32-vCPU ARM runner with 32 sample processes by default. It can be
 started manually with an optional sample id, or for a pull request by adding
 `[BENCHMARK TEST]` to its title. The workflow publishes the Markdown summary and
 uploads both reports as an artifact.
 
-Run `bun run start` and open the `datasets/srj19` Cosmos fixture to step the
-selected sample through `GenericSolverDebugger`. The page has Previous/Next,
-sample dropdown, and range controls and stores the selection in the `sample`
-URL parameter.
+Run `bun run start` and inspect the SRJ29 fixtures to step through the selected
+sample. The derivative dataset also publishes dedicated Cosmos pages for the
+first ten samples.
 
 ## Dataset 02
 

package/lib/fanout-solver.ts

@@ -18,8 +18,10 @@ import {
 } from "./route-bus"
 import { routeSingleLayerWithAdaptiveExits } from "./route-single-layer-adaptive-exits"
 import { routeSingleLayerWithPushAndShove } from "./route-single-layer-push-shove"
+import { validateFanoutSolution } from "./validate-fanout-solution"
 import type {
   AssignmentAttempt,
+  Bounds,
   FanoutAttemptSummary,
   FanoutBorderDistribution,
   FanoutRoutePlan,
@@ -34,6 +36,7 @@ interface ResolvedFanoutConfig {
   viaHoleDiameter: number
   clearance: number
   compactBusTracks: boolean
+  allowSameNetMerges: boolean
   singleLayerPushAndShove: boolean
   singleLayerAdaptiveExits: boolean
   borderDistribution: FanoutBorderDistribution
@@ -123,6 +126,7 @@ function resolveConfig(
     viaHoleDiameter,
     clearance,
     compactBusTracks: options.compactBusTracks ?? false,
+    allowSameNetMerges: options.allowSameNetMerges ?? false,
     singleLayerPushAndShove: options.singleLayerPushAndShove ?? false,
     singleLayerAdaptiveExits: options.singleLayerAdaptiveExits ?? false,
     borderDistribution,
@@ -303,6 +307,7 @@ function getCandidateEscapeLayersForBus(params: {
         viaHoleDiameter: config.viaHoleDiameter,
         clearance: config.clearance,
         compactBusTracks: config.compactBusTracks,
+        allowSameNetMerges: config.allowSameNetMerges,
         staticClearanceCache,
       }) !== null,
   )
@@ -422,6 +427,35 @@ export class FanoutSolver extends BaseSolver {
     return "FanoutSolver"
   }
 
+  private getValidationBoundary(): Bounds {
+    if (this.options.sharedBoundary) return this.options.sharedBoundary
+    const firstBoundary = this.preparedBuses[0]?.sharedBoundary
+    if (!firstBoundary) return this.inputSrj.bounds
+    return this.preparedBuses.slice(1).reduce<Bounds>(
+      (boundary, bus) => ({
+        minX: Math.min(boundary.minX, bus.sharedBoundary.minX),
+        maxX: Math.max(boundary.maxX, bus.sharedBoundary.maxX),
+        minY: Math.min(boundary.minY, bus.sharedBoundary.minY),
+        maxY: Math.max(boundary.maxY, bus.sharedBoundary.maxY),
+      }),
+      { ...firstBoundary },
+    )
+  }
+
+  private validateCompletePlans(
+    plans: readonly FanoutRoutePlan[],
+    outputSrj: SimpleRouteJson,
+  ) {
+    return validateFanoutSolution({
+      inputSrj: this.inputSrj,
+      outputSrj,
+      plans,
+      preparedBuses: this.preparedBuses,
+      sharedBoundary: this.getValidationBoundary(),
+      clearance: this.config.clearance,
+    })
+  }
+
   private evaluateAssignmentWithStrategy(
     assignmentIndex: number,
     busLayerAssignments: Readonly<Record<string, string>>,
@@ -483,7 +517,12 @@ export class FanoutSolver extends BaseSolver {
           `FanoutSolver: assignment ${assignmentIndex} has no layer for bus "${bus.busId}"`,
         )
       }
-      routingPrefixKey += `${targetLayer.length}:${targetLayer};`
+      // The routing order can change between assignments (notably for
+      // group-by-layer search). A layer-only key can therefore replay a
+      // prefix belonging to a different bus and duplicate or drop plans when
+      // buses contain multiple connections. Include the bus identity so the
+      // cache remains valid for grouped power/signal lanes.
+      routingPrefixKey += `${bus.busId.length}:${bus.busId};${targetLayer.length}:${targetLayer};`
       const cachedPrefix = this.routingPrefixCache.get(routingPrefixKey)
       if (cachedPrefix) {
         plans = [...cachedPrefix.plans]
@@ -503,6 +542,7 @@ export class FanoutSolver extends BaseSolver {
         viaHoleDiameter: this.config.viaHoleDiameter,
         clearance: this.config.clearance,
         compactBusTracks: this.config.compactBusTracks,
+        allowSameNetMerges: this.config.allowSameNetMerges,
         staticClearanceCache: this.routeStaticClearanceCache,
         blockingBusCounts: currentBusBlockingCounts,
       })
@@ -524,6 +564,30 @@ export class FanoutSolver extends BaseSolver {
       })
     }
 
+    let validationIssues: FanoutAttemptSummary["validationIssues"]
+    let outputSrj = buildOutputSimpleRouteJson({
+      inputSrj: this.inputSrj,
+      plans,
+      layerNames: this.config.layerNames,
+    })
+    const validation =
+      plans.length === this.inputSrj.connections.length
+        ? this.validateCompletePlans(plans, outputSrj)
+        : null
+    if (validation && !validation.valid) {
+      // Every route-producing strategy must pass the same final layer-aware,
+      // same-net-aware copper validation before it can be scored as complete.
+      validationIssues = validation.issues
+      plans = []
+      failedBusIds = this.preparedBuses.map((bus) => bus.busId)
+      blockingBusCounts.clear()
+      outputSrj = buildOutputSimpleRouteJson({
+        inputSrj: this.inputSrj,
+        plans,
+        layerNames: this.config.layerNames,
+      })
+    }
+
     const routedBusCount = this.preparedBuses.length - failedBusIds.length
     const routeLength = plans.reduce((total, plan) => total + plan.length, 0)
     const unroutedConnectionCount =
@@ -541,6 +605,7 @@ export class FanoutSolver extends BaseSolver {
       routedConnectionCount: plans.length,
       failedBusIds,
       score,
+      ...(validationIssues ? { validationIssues } : {}),
     }
 
     return {
@@ -549,11 +614,7 @@ export class FanoutSolver extends BaseSolver {
       blockingBusIds: [...blockingBusCounts.entries()]
         .toSorted(([, firstCount], [, secondCount]) => secondCount - firstCount)
         .map(([busId]) => busId),
-      outputSrj: buildOutputSimpleRouteJson({
-        inputSrj: this.inputSrj,
-        plans,
-        layerNames: this.config.layerNames,
-      }),
+      outputSrj,
     }
   }
 
@@ -596,8 +657,10 @@ export class FanoutSolver extends BaseSolver {
    * Search layer assignments and track alternatives together. The regular
    * assignment loop commits to one route per bus before the next bus is
    * considered, so a locally-valid track can still starve a later bus. A
-   * bounded beam keeps several grouped-layer route prefixes alive and is
-   * especially useful for the many singleton buses in the SRJ19 samples.
+   * bounded beam keeps several grouped-layer route prefixes alive. It also
+   * evaluates multi-connection buses atomically, so one promising route for a
+   * power or signal lane cannot starve a later bus before the solver explores
+   * an alternate layer/track combination.
    */
   private evaluateGroupedBeam(
     assignmentIndex: number,
@@ -605,9 +668,12 @@ export class FanoutSolver extends BaseSolver {
   ): EvaluatedAssignment | null {
     if (this.config.escapeLayers.length < 2) return null
     if (this.preparedBuses.length > 56) return null
-    if (this.preparedBuses.some((bus) => bus.connections.length !== 1)) {
-      return null
-    }
+    const totalConnections = this.inputSrj.connections.length
+    // Multi-pin alternatives grow with both the bus width and the number of
+    // layer prefixes. Keep the new search bounded on the small/medium grouped
+    // problems it can improve, then let the regular assignment/repair search
+    // handle the very large benchmark samples without starving them.
+    if (totalConnections > 64) return null
     if (new Set(this.preparedBuses.map((bus) => bus.componentId)).size !== 1) {
       return null
     }
@@ -635,8 +701,17 @@ export class FanoutSolver extends BaseSolver {
       )
     })
 
-    const beamWidth = 128
-    const alternativesPerLayer = 4
+    const isSmallProblem = totalConnections <= 24
+    const hasMultiConnectionBus = this.preparedBuses.some(
+      (bus) => bus.connections.length > 1,
+    )
+    // Preserve the broad track search for small singleton problems. Grouped
+    // power buses already branch across every candidate layer and make each
+    // route-alternative expansion combinatorial, so retain layer diversity but
+    // only one atomic route per layer for those buses.
+    const beamWidth = isSmallProblem ? 48 : totalConnections <= 32 ? 24 : 12
+    const alternativesPerLayer =
+      isSmallProblem && !hasMultiConnectionBus ? 4 : 1
     let states: GroupedBeamState[] = [{ assignment: {}, plans: [] }]
 
     const getStateScore = (state: GroupedBeamState): number => {
@@ -684,6 +759,7 @@ export class FanoutSolver extends BaseSolver {
               viaHoleDiameter: this.config.viaHoleDiameter,
               clearance: this.config.clearance,
               compactBusTracks: this.config.compactBusTracks,
+              allowSameNetMerges: this.config.allowSameNetMerges,
               staticClearanceCache: this.routeStaticClearanceCache,
             },
             alternativesPerLayer,
@@ -722,6 +798,17 @@ export class FanoutSolver extends BaseSolver {
 
     const bestState = states[0]
     if (!bestState) return null
+    const outputSrj = buildOutputSimpleRouteJson({
+      inputSrj: this.inputSrj,
+      plans: bestState.plans,
+      layerNames: this.config.layerNames,
+    })
+    if (
+      bestState.plans.length === this.inputSrj.connections.length &&
+      !this.validateCompletePlans(bestState.plans, outputSrj).valid
+    ) {
+      return null
+    }
     const score =
       bestState.plans.length === this.inputSrj.connections.length
         ? bestState.plans.reduce((total, plan) => total + plan.length, 0) +
@@ -742,11 +829,7 @@ export class FanoutSolver extends BaseSolver {
       summary,
       plans: bestState.plans,
       blockingBusIds: [],
-      outputSrj: buildOutputSimpleRouteJson({
-        inputSrj: this.inputSrj,
-        plans: bestState.plans,
-        layerNames: this.config.layerNames,
-      }),
+      outputSrj,
     }
   }
 
@@ -958,6 +1041,15 @@ export class FanoutSolver extends BaseSolver {
         "FanoutSolver: getOutput() called before a complete fanout was solved",
       )
     }
+    const validation = this.validateCompletePlans(
+      this.bestAttempt.plans,
+      this.bestAttempt.outputSrj,
+    )
+    if (!validation.valid) {
+      throw new Error(
+        `FanoutSolver: completed output failed validation: ${validation.issues[0]?.message ?? "unknown validation error"}`,
+      )
+    }
     return {
       simpleRouteJson: this.bestAttempt.outputSrj,
       fanoutTraces: this.bestAttempt.plans.map((plan) => plan.trace),
@@ -978,6 +1070,7 @@ export class FanoutSolver extends BaseSolver {
         this.preparedBuses.map((bus) => [bus.busId, bus.direction]),
       ),
       attempts: [...this.attempts],
+      validation,
     }
   }
 

package/lib/geometry.ts

@@ -3,12 +3,27 @@ import type { Point2D, RoutedSegment } from "./types"
 
 const EPSILON = 1e-9
 
-type ShapeAwareObstacle = Obstacle & { shape?: "circle" }
+type ShapeAwareObstacle = Obstacle & {
+  shape?: "circle"
+  ccwRotationDegrees?: number
+}
 
 function obstacleIsCircular(obstacle: Obstacle): boolean {
   return (obstacle as ShapeAwareObstacle).shape === "circle"
 }
 
+function toObstacleLocalPoint(point: Point2D, obstacle: Obstacle): Point2D {
+  const rotationRadians =
+    (-((obstacle as ShapeAwareObstacle).ccwRotationDegrees ?? 0) * Math.PI) /
+    180
+  const dx = point.x - obstacle.center.x
+  const dy = point.y - obstacle.center.y
+  return {
+    x: dx * Math.cos(rotationRadians) - dy * Math.sin(rotationRadians),
+    y: dx * Math.sin(rotationRadians) + dy * Math.cos(rotationRadians),
+  }
+}
+
 export function distance(a: Point2D, b: Point2D): number {
   return Math.hypot(a.x - b.x, a.y - b.y)
 }
@@ -76,9 +91,10 @@ export function pointIsInsideObstacle(
   if (obstacleIsCircular(obstacle)) {
     return distance(point, obstacle.center) <= obstacle.width / 2 + tolerance
   }
+  const localPoint = toObstacleLocalPoint(point, obstacle)
   return (
-    Math.abs(point.x - obstacle.center.x) <= obstacle.width / 2 + tolerance &&
-    Math.abs(point.y - obstacle.center.y) <= obstacle.height / 2 + tolerance
+    Math.abs(localPoint.x) <= obstacle.width / 2 + tolerance &&
+    Math.abs(localPoint.y) <= obstacle.height / 2 + tolerance
   )
 }
 
@@ -89,14 +105,9 @@ export function distancePointToObstacle(
   if (obstacleIsCircular(obstacle)) {
     return Math.max(0, distance(point, obstacle.center) - obstacle.width / 2)
   }
-  const dx = Math.max(
-    Math.abs(point.x - obstacle.center.x) - obstacle.width / 2,
-    0,
-  )
-  const dy = Math.max(
-    Math.abs(point.y - obstacle.center.y) - obstacle.height / 2,
-    0,
-  )
+  const localPoint = toObstacleLocalPoint(point, obstacle)
+  const dx = Math.max(Math.abs(localPoint.x) - obstacle.width / 2, 0)
+  const dy = Math.max(Math.abs(localPoint.y) - obstacle.height / 2, 0)
   return Math.hypot(dx, dy)
 }
 
@@ -111,16 +122,24 @@ export function distanceSegmentToObstacle(
         obstacle.width / 2,
     )
   }
+  const localStart = toObstacleLocalPoint(segment.start, obstacle)
+  const localEnd = toObstacleLocalPoint(segment.end, obstacle)
+  if (
+    Math.abs(localStart.x) <= obstacle.width / 2 + EPSILON &&
+    Math.abs(localStart.y) <= obstacle.height / 2 + EPSILON
+  ) {
+    return 0
+  }
   if (
-    pointIsInsideObstacle(segment.start, obstacle) ||
-    pointIsInsideObstacle(segment.end, obstacle)
+    Math.abs(localEnd.x) <= obstacle.width / 2 + EPSILON &&
+    Math.abs(localEnd.y) <= obstacle.height / 2 + EPSILON
   ) {
     return 0
   }
-  const minX = obstacle.center.x - obstacle.width / 2
-  const maxX = obstacle.center.x + obstacle.width / 2
-  const minY = obstacle.center.y - obstacle.height / 2
-  const maxY = obstacle.center.y + obstacle.height / 2
+  const minX = -obstacle.width / 2
+  const maxX = obstacle.width / 2
+  const minY = -obstacle.height / 2
+  const maxY = obstacle.height / 2
   const corners = [
     { x: minX, y: minY },
     { x: maxX, y: minY },
@@ -133,8 +152,8 @@ export function distanceSegmentToObstacle(
     minimumDistance = Math.min(
       minimumDistance,
       distanceSegmentToSegment(
-        segment.start,
-        segment.end,
+        localStart,
+        localEnd,
         corners[index]!,
         corners[(index + 1) % corners.length]!,
       ),

package/lib/index.ts

@@ -1,6 +1,7 @@
 export { FanoutSolver } from "./fanout-solver"
 export { getCopperLayerColor } from "./layer-colors"
 export { getCopperLayerNames } from "./layer-names"
+export { validateFanoutSolution } from "./validate-fanout-solution"
 export type {
   Bounds,
   FanoutAttemptSummary,
@@ -15,6 +16,10 @@ export type {
   FanoutDirection,
   FanoutEdge,
   FanoutPlaneTermination,
+  FanoutRoutePlan,
   FanoutSolverOptions,
   FanoutSolverOutput,
+  FanoutValidationIssue,
+  FanoutValidationReport,
+  PreparedBus,
 } from "./types"

package/lib/net-identity.ts

@@ -0,0 +1,163 @@
+import type {
+  Obstacle,
+  SimpleRouteConnection,
+  SimpleRouteJson,
+} from "@tscircuit/capacity-autorouter"
+
+interface ElectricalNetIdentity {
+  connectionNetKeys: Map<string, string>
+  tokenNetKeys: Map<string, Set<string>>
+}
+
+const identityCache = new WeakMap<SimpleRouteJson, ElectricalNetIdentity>()
+
+export function getConnectionNetKey(connection: SimpleRouteConnection): string {
+  return (
+    connection.netConnectionName ??
+    connection.rootConnectionName ??
+    connection.name
+  )
+}
+
+function addTokenNet(
+  tokenNetKeys: Map<string, Set<string>>,
+  token: string | undefined,
+  netKey: string,
+): boolean {
+  if (!token) return false
+  const keys = tokenNetKeys.get(token) ?? new Set<string>()
+  const sizeBefore = keys.size
+  keys.add(netKey)
+  tokenNetKeys.set(token, keys)
+  return keys.size !== sizeBefore
+}
+
+function getKnownNetKeys(
+  tokenNetKeys: Map<string, Set<string>>,
+  tokens: readonly string[],
+): Set<string> {
+  const keys = new Set<string>()
+  for (const token of tokens) {
+    for (const key of tokenNetKeys.get(token) ?? []) keys.add(key)
+  }
+  return keys
+}
+
+function createElectricalNetIdentity(
+  srj: SimpleRouteJson,
+): ElectricalNetIdentity {
+  const connectionNetKeys = new Map<string, string>()
+  const tokenNetKeys = new Map<string, Set<string>>()
+
+  for (const connection of srj.connections) {
+    const netKey = getConnectionNetKey(connection)
+    connectionNetKeys.set(connection.name, netKey)
+    addTokenNet(tokenNetKeys, connection.name, netKey)
+    addTokenNet(tokenNetKeys, connection.rootConnectionName, netKey)
+    addTokenNet(tokenNetKeys, connection.netConnectionName, netKey)
+    for (const point of connection.pointsToConnect) {
+      addTokenNet(tokenNetKeys, point.pointId, netKey)
+      addTokenNet(tokenNetKeys, point.pcb_port_id, netKey)
+    }
+  }
+
+  for (const trace of srj.traces ?? []) {
+    const netKey = trace.connection_name
+      ? connectionNetKeys.get(trace.connection_name)
+      : undefined
+    if (!netKey) continue
+    addTokenNet(tokenNetKeys, trace.pcb_trace_id, netKey)
+    for (const token of trace.connectsTo ?? []) {
+      addTokenNet(tokenNetKeys, token, netKey)
+    }
+  }
+
+  // Obstacle metadata often contains both a connection id and a lower-level
+  // connectivity id. Propagate the known net across that metadata so another
+  // pad that only names the connectivity id is still recognized as same-net.
+  for (let pass = 0; pass < 2; pass++) {
+    let changed = false
+    for (const obstacle of srj.obstacles) {
+      const netKeys = getKnownNetKeys(tokenNetKeys, obstacle.connectedTo)
+      if (netKeys.size !== 1) continue
+      const netKey = [...netKeys][0]!
+      for (const token of obstacle.connectedTo) {
+        changed = addTokenNet(tokenNetKeys, token, netKey) || changed
+      }
+    }
+    if (!changed) break
+  }
+
+  const parentByNetKey = new Map<string, string>()
+  const findRoot = (netKey: string): string => {
+    const parent = parentByNetKey.get(netKey) ?? netKey
+    parentByNetKey.set(netKey, parent)
+    if (parent === netKey) return netKey
+    const root = findRoot(parent)
+    parentByNetKey.set(netKey, root)
+    return root
+  }
+  const union = (first: string, second: string): void => {
+    const firstRoot = findRoot(first)
+    const secondRoot = findRoot(second)
+    if (firstRoot !== secondRoot) parentByNetKey.set(secondRoot, firstRoot)
+  }
+  for (const netKeys of tokenNetKeys.values()) {
+    const [firstNetKey, ...otherNetKeys] = [...netKeys]
+    if (!firstNetKey) continue
+    for (const otherNetKey of otherNetKeys) union(firstNetKey, otherNetKey)
+  }
+  for (const connectedTokens of [
+    ...srj.obstacles.map((obstacle) => obstacle.connectedTo),
+    ...(srj.traces ?? []).map((trace) => trace.connectsTo ?? []),
+  ]) {
+    const [firstNetKey, ...otherNetKeys] = [
+      ...getKnownNetKeys(tokenNetKeys, connectedTokens),
+    ]
+    if (!firstNetKey) continue
+    for (const otherNetKey of otherNetKeys) union(firstNetKey, otherNetKey)
+  }
+  for (const [connectionName, netKey] of connectionNetKeys) {
+    connectionNetKeys.set(connectionName, findRoot(netKey))
+  }
+  for (const [token, netKeys] of tokenNetKeys) {
+    tokenNetKeys.set(
+      token,
+      new Set([...netKeys].map((netKey) => findRoot(netKey))),
+    )
+  }
+
+  return { connectionNetKeys, tokenNetKeys }
+}
+
+function getElectricalNetIdentity(srj: SimpleRouteJson): ElectricalNetIdentity {
+  const cached = identityCache.get(srj)
+  if (cached) return cached
+  const identity = createElectricalNetIdentity(srj)
+  identityCache.set(srj, identity)
+  return identity
+}
+
+export function connectionsShareElectricalNet(
+  srj: SimpleRouteJson,
+  firstConnectionName: string,
+  secondConnectionName: string,
+): boolean {
+  const identity = getElectricalNetIdentity(srj)
+  const firstNet = identity.connectionNetKeys.get(firstConnectionName)
+  const secondNet = identity.connectionNetKeys.get(secondConnectionName)
+  return firstNet !== undefined && firstNet === secondNet
+}
+
+export function obstacleSharesElectricalNet(
+  srj: SimpleRouteJson,
+  obstacle: Obstacle,
+  connectionName: string,
+): boolean {
+  const identity = getElectricalNetIdentity(srj)
+  const connectionNet = identity.connectionNetKeys.get(connectionName)
+  if (!connectionNet) return false
+  return obstacle.connectedTo.some((token) =>
+    identity.tokenNetKeys.get(token)?.has(connectionNet),
+  )
+}