@tscircuit/fanout-solver 0.0.64 → 0.0.66

package/README.md

@@ -282,8 +282,8 @@ extents.
 
 ## Dataset 31 benchmark
 
-Run `./benchmark.sh` (or `bun run benchmark`) to benchmark **all 24 dataset 31
-directional cases: 12 AM62L and 12 RK3308** from
+Run `./benchmark.sh` (or `bun run benchmark`) to benchmark **all 36 dataset 31
+directional cases: 12 AM62L, 12 RK3308, and 12 K230** from
 [`tscircuit/dataset-fanout31-am62l`](https://github.com/tscircuit/dataset-fanout31-am62l).
 The upstream revision is pinned in `scripts/generate-repro/package.json` and
 recorded in every report. Other datasets remain available for regression tests
@@ -294,6 +294,7 @@ and the debugger, but have no benchmark commands or workflows.
 ./benchmark.sh --list
 ./benchmark.sh --sample 11-left-center
 ./benchmark.sh --sample 13-rk3308-top-left-offset
+./benchmark.sh --sample 25-k230-top-left-offset
 ./benchmark.sh --concurrency 8 --sample-timeout-seconds 300
 ```
 
@@ -307,11 +308,16 @@ constraints:
 | --- | ---: | ---: | ---: | ---: | ---: |
 | AM62L | 12 | 33 | 102 | 135 | 573 |
 | RK3308 | 12 | 49 | 113 | 162 | 451 |
-
-Both families have nine DDR signal buses. The RK3308 samples use a 355-ball SoC
-and 96-ball DDR3L RAM, with the RAM placed on each side at three offsets.
-The timed workers run
-**this checkout's solver**, not the upstream package's released solver.
+| K230 | 12 | 65 | 106 | 171 | 790 |
+
+AM62L and RK3308 have nine DDR signal buses each. The RK3308 samples use a
+355-ball SoC and 96-ball DDR3L RAM. The K230 samples use a 390-ball SoC and two
+200-ball x16 LPDDR4 RAM packages, with 17 signal buses and six differential pairs.
+Each family places its RAM on all four sides at three offsets per side. K230
+retains both physical RAM endpoints of its shared RESET net; the two RAM packages
+have separate breakout regions. All 790 pads in each K230 case remain obstacles,
+including unused signal and supply pads. The timed workers run **this checkout's
+solver**, not the upstream package's released solver.
 To capture the inputs without solving, use `bun run generate:dataset31`.
 The optional `--dataset dataset31` flag is accepted for explicit CI invocation;
 other dataset selections are rejected.
@@ -343,20 +349,21 @@ Timed-out workers do not retain their in-flight routing counts.
 Every solved case also writes `benchmark-results/<sample-id>.svg`. These SVGs
 are committed so route changes can be reviewed in Git. A run replaces the selected
 cases' snapshots and removes their stale SVGs if they no longer solve; filtered
-runs preserve unselected snapshots. JSON reports and captured inputs remain
-ignored. CI includes the SVGs in its benchmark artifacts.
+runs preserve unselected snapshots. The latest JSON and Markdown reports are
+also committed; captured inputs remain ignored. CI includes the reports, inputs,
+and SVGs in its benchmark artifacts.
 Compare reports with the same dataset revision and budgets to track progress.
 A case is solved only when every SoC connection has validated fanout: all 135
-connections for AM62L or all 162 for RK3308. This covers the SoC fanout phase; RAM
-fanout and downstream inter-chip routing are separate phases. Partial, error,
-and timeout rows are benchmark results (exit 0); invalid CLI arguments or report
+connections for AM62L, all 162 for RK3308, or all 171 for K230. This covers the SoC
+fanout phase; RAM fanout and downstream inter-chip routing are separate phases.
+Partial, error, and timeout rows are benchmark results (exit 0); invalid CLI arguments or report
 I/O failures are command failures (nonzero exit).
 
 ### PR comment trigger
 
 Once `.github/workflows/benchmark.yml` is on the default branch, a repository
 writer can comment **`/benchmark`** on an open PR. The workflow captures that
-PR's exact head SHA, runs all 24 dataset 31 samples on a **32-vCPU Blacksmith ARM**
+PR's exact head SHA, runs all 36 dataset 31 samples on a **32-vCPU Blacksmith ARM**
 runner, then updates a status comment with solve totals, per-sample results,
 and a link to the complete JSON/Markdown reports and captured inputs. The Actions
 UI also supports a manual run, optionally supplying an open PR number. No custom
@@ -522,8 +529,8 @@ bun run render:dataset
 bun run start
 ```
 
-The benchmark runs all 24 dataset 31 AM62L and RK3308 cases and reports solve
-counts, validation, and timing. `bun run start` opens all regression
+The benchmark runs all 36 dataset 31 AM62L, RK3308, and K230 cases and reports
+solve counts, validation, and timing. `bun run start` opens all regression
 datasets in the standard tscircuit solver debugger. `bun run
 render:dataset` writes `graphics-debug` PNGs under one subdirectory per dataset,
 with a red shared boundary, gray component courtyards, and green fanout-exit

package/lib/fanout-solver.ts

@@ -39,6 +39,13 @@ import {
   routeBusAlternatives,
   routeBusAlternativesSteps,
 } from "./route-bus"
+import { routePeripheralSourceEscapesSteps } from "./route-peripheral-source-escapes"
+import { routeStagedPerimeterBusSteps } from "./route-staged-perimeter-bus"
+import { routeReservedSourceBusesSteps } from "./route-reserved-source-buses"
+import { repairPeripheralBusLengthsSteps } from "./repair-peripheral-bus-lengths"
+import { routeSplitPerimeterSourceEscapesSteps } from "./route-split-perimeter-source-escapes"
+import { routeSplitPerimeterBusSteps } from "./route-split-perimeter-bus"
+import { routeShallowSplitPerimeterBusSteps } from "./route-shallow-split-perimeter-bus"
 import { routeSingleLayerWithAdaptiveExitsSteps } from "./route-single-layer-adaptive-exits"
 import { routeSingleLayerWithPushAndShove } from "./route-single-layer-push-shove"
 import { getRuntimeProcess } from "./runtime-process"
@@ -84,6 +91,8 @@ interface ResolvedFanoutConfig {
 
 interface EvaluatedAssignment extends AssignmentAttempt {
   blockingBusIds: string[]
+  /** The bounded peripheral strategy may finish after complete validation. */
+  stopAfterCompleteValidation?: true
 }
 
 interface GroupedBeamState {
@@ -94,6 +103,7 @@ interface GroupedBeamState {
 interface MixedTerminationState {
   plans: FanoutRoutePlan[]
   failedBusIds: string[]
+  stopAfterCompleteValidation?: true
 }
 
 type RoutingStrategy = "default" | "group-by-layer" | "deep-first"
@@ -513,6 +523,43 @@ function createInitialLayerAssignment(params: {
     ) {
       assignment[bus.busId] = sourceLayer
     } else if (viaLayers.length > 0) {
+      // A source strictly inside a wide field can be enclosed by its routes.
+      // Boundary sources still have an outward channel, so preserve the
+      // ordinary layer preference for those buses.
+      const sourceXs = bus.connections.map(
+        (connection) => connection.sourcePoint.x,
+      )
+      const sourceYs = bus.connections.map(
+        (connection) => connection.sourcePoint.y,
+      )
+      const embeddedSingletonCount = (layer: string) =>
+        buses.filter((other) => {
+          const point = other.connections[0]?.sourcePoint
+          return (
+            other.termination.type === "boundary" &&
+            point !== undefined &&
+            point.x > Math.min(...sourceXs) + 1e-9 &&
+            point.x < Math.max(...sourceXs) - 1e-9 &&
+            point.y > Math.min(...sourceYs) + 1e-9 &&
+            point.y < Math.max(...sourceYs) - 1e-9 &&
+            getCommonExplicitExitTargetLayer(other) === layer &&
+            isDenseSingletonEmbeddedInMultiLayerWideBus({
+              singletonBus: other,
+              singletonTargetLayer: layer,
+              wideBuses: [bus],
+            })
+          )
+        }).length
+      const isolatedLayers = viaLayers.toSorted(
+        (a, b) => embeddedSingletonCount(a) - embeddedSingletonCount(b),
+      )
+      if (
+        embeddedSingletonCount(isolatedLayers[0]!) <
+        embeddedSingletonCount(viaLayers[0]!)
+      ) {
+        assignment[bus.busId] = isolatedLayers[0]!
+        continue
+      }
       if (
         preferOrderedCoordinatedWindingLayers &&
         busUsesCoordinatedWinding(bus)
@@ -1535,6 +1582,127 @@ export class FanoutSolver extends BaseSolver {
     })
   }
 
+  /** Reserve source escapes before joining complete buses around the package. */
+  private *routePeripheralMixedTerminationSteps(params: {
+    busLayerAssignments: Readonly<Record<string, string>>
+    busesInRoutingOrder: readonly PreparedBus[]
+  }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
+    if (this.config.allowBlindAndBuriedVias) return null
+    const bus = params.busesInRoutingOrder.find(
+      (candidate) =>
+        candidate.termination.type === "boundary" &&
+        (candidate.exitEdge === "right" || candidate.exitEdge === "left") &&
+        candidate.connections.length >= 16 &&
+        candidate.componentObstacles.length >= 200,
+    )
+    if (!bus) return null
+    const targetLayer = params.busLayerAssignments[bus.busId]
+    if (!targetLayer) return null
+    const targetLayerByBusId = new Map(
+      Object.entries(params.busLayerAssignments),
+    )
+    this.setInProgressPlans({
+      phase: "route-peripheral-source-escapes",
+      plans: [],
+      busId: bus.busId,
+    })
+    const sourceSteps = (
+      bus.exitEdge === "left"
+        ? routeSplitPerimeterSourceEscapesSteps
+        : routePeripheralSourceEscapesSteps
+    )({
+      ...this.config,
+      srj: this.routingSrj,
+      buses: this.preparedBuses,
+      bus,
+      targetLayer,
+      targetLayerByBusId,
+    })
+    let sourceResult = sourceSteps.next()
+    while (!sourceResult.done) {
+      yield
+      sourceResult = sourceSteps.next()
+    }
+    if (!sourceResult.value) return null
+    let source = sourceResult.value
+    const stageParams = {
+      ...this.config,
+      ...source,
+      srj: this.routingSrj,
+      bus,
+      targetLayer,
+    }
+    const stageSteps =
+      "lowerConnectionIndices" in source
+        ? routeSplitPerimeterBusSteps({ ...stageParams, ...source })
+        : routeStagedPerimeterBusSteps(stageParams)
+    let stageResult = stageSteps.next()
+    while (!stageResult.done) {
+      yield
+      stageResult = stageSteps.next()
+    }
+    let stagePlans = stageResult.value
+    if (!stagePlans && "lowerConnectionIndices" in source) {
+      const shallowSteps = routeShallowSplitPerimeterBusSteps({
+        ...stageParams,
+        ...source,
+        buses: this.preparedBuses,
+      })
+      let shallowResult = shallowSteps.next()
+      while (!shallowResult.done) {
+        yield
+        shallowResult = shallowSteps.next()
+      }
+      if (shallowResult.value) {
+        source = shallowResult.value
+        stagePlans = shallowResult.value.plans
+      }
+    }
+    if (!stagePlans) return null
+    this.setInProgressPlans({
+      phase: "route-peripheral-bus-continuations",
+      plans: stagePlans,
+      busId: bus.busId,
+    })
+    const remainingSteps = routeReservedSourceBusesSteps({
+      ...this.config,
+      srj: this.routingSrj,
+      buses: this.preparedBuses,
+      sourceEscapes: source.sourceEscapes,
+      sourceBoundary: source.sourceBoundary,
+      initialPlans: stagePlans,
+      targetLayerByBusId,
+    })
+    let remainingResult = remainingSteps.next()
+    while (!remainingResult.done) {
+      yield
+      remainingResult = remainingSteps.next()
+    }
+    if (!remainingResult.value) return null
+    const repairSteps = repairPeripheralBusLengthsSteps({
+      ...this.config,
+      srj: this.routingSrj,
+      inputSrj: this.inputSrj,
+      plans: remainingResult.value,
+      preparedBuses: this.preparedBuses,
+      sharedBoundary: this.getValidationBoundary(),
+    })
+    let repairResult = repairSteps.next()
+    while (!repairResult.done) {
+      yield
+      repairResult = repairSteps.next()
+    }
+    if (!repairResult.value) return null
+    const plans = repairResult.value
+    const output = buildOutputSimpleRouteJson({
+      inputSrj: this.inputSrj,
+      plans,
+      layerNames: this.config.layerNames,
+    })
+    if (!this.validateCompletePlans(plans, output).valid) return null
+    return { plans, failedBusIds: [], stopAfterCompleteValidation: true }
+  }
+
   /**
    * Through-all source vias from a wide boundary bus can consume the only
    * legal dogbone channel for nearby plane pads. Conversely, routing hundreds
@@ -5142,6 +5310,23 @@ export class FanoutSolver extends BaseSolver {
 
     let mixedTerminationState: MixedTerminationState | null = null
     if (!useSingleLayerPushAndShove && routingStrategy === "default") {
+      const peripheralSolver = this.createWorkSolver(
+        "PeripheralMixedTerminationSolver",
+        this.routePeripheralMixedTerminationSteps({
+          busLayerAssignments,
+          busesInRoutingOrder,
+        }),
+      )
+      mixedTerminationState = (yield {
+        type: "subsolver",
+        solver: peripheralSolver,
+      }) as MixedTerminationState | null
+    }
+    if (
+      !mixedTerminationState &&
+      !useSingleLayerPushAndShove &&
+      routingStrategy === "default"
+    ) {
       const denseSolver = this.createWorkSolver(
         "DenseMixedTerminationSolver",
         this.routeDenseThroughAllMixedTerminationSteps({
@@ -5341,6 +5526,10 @@ export class FanoutSolver extends BaseSolver {
     return {
       summary,
       plans,
+      ...(mixedTerminationState?.stopAfterCompleteValidation &&
+      validation?.valid
+        ? { stopAfterCompleteValidation: true as const }
+        : {}),
       blockingBusIds: [...blockingBusCounts.entries()]
         .toSorted(([, firstCount], [, secondCount]) => secondCount - firstCount)
         .map(([busId]) => busId),
@@ -5361,7 +5550,8 @@ export class FanoutSolver extends BaseSolver {
     if (
       bestAttempt.summary.routedConnectionCount ===
         this.inputSrj.connections.length &&
-      this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0
+      (bestAttempt.stopAfterCompleteValidation ||
+        this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0)
     ) {
       return bestAttempt
     }
@@ -5378,7 +5568,8 @@ export class FanoutSolver extends BaseSolver {
       if (
         bestAttempt.summary.routedConnectionCount ===
           this.inputSrj.connections.length &&
-        this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0
+        (bestAttempt.stopAfterCompleteValidation ||
+          this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0)
       ) {
         return bestAttempt
       }
@@ -5932,10 +6123,11 @@ export class FanoutSolver extends BaseSolver {
       bestScore: this.bestAttempt.summary.score,
     }
     if (
-      this.groupedBeamEvaluated &&
-      attempt.summary.routedConnectionCount ===
-        this.inputSrj.connections.length &&
-      this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0
+      (attempt.stopAfterCompleteValidation && this.hasCompleteBestAttempt()) ||
+      (this.groupedBeamEvaluated &&
+        attempt.summary.routedConnectionCount ===
+          this.inputSrj.connections.length &&
+        this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0)
     ) {
       this.completeBestAttemptEndpoints()
       this.solved = true

package/lib/get-free-boundary-tracks.ts

@@ -0,0 +1,102 @@
+import { getCornerBandSide } from "./boundary-exit"
+import type { RouteBusParams } from "./route-bus"
+
+/** Midpoints of unoccupied edge intervals, clipped to the bus's declared band. */
+export function getFreeBoundaryTracks(
+  params: Pick<
+    RouteBusParams,
+    | "bus"
+    | "targetLayer"
+    | "acceptedPlans"
+    | "reservedVias"
+    | "traceWidth"
+    | "clearance"
+  >,
+): number[] {
+  const { bus, targetLayer, traceWidth, clearance } = params
+  if (!bus.exitEdge) return []
+  const vertical = bus.exitEdge === "left" || bus.exitEdge === "right"
+  const along = vertical ? "y" : "x"
+  const across = vertical ? "x" : "y"
+  const boundary = bus.sharedBoundary
+  const edge =
+    bus.exitEdge === "left"
+      ? boundary.minX
+      : bus.exitEdge === "right"
+        ? boundary.maxX
+        : bus.exitEdge === "bottom"
+          ? boundary.minY
+          : boundary.maxY
+  const lower = vertical ? boundary.minY : boundary.minX
+  const upper = vertical ? boundary.maxY : boundary.maxX
+  const middle = (lower + upper) / 2
+  const side = getCornerBandSide(bus.exitEdge, bus.preferredExit)
+  const minimum = (side === "maximum" ? middle : lower) + traceWidth / 2
+  const maximum = (side === "minimum" ? middle : upper) - traceWidth / 2
+  const blocked: [number, number][] = []
+  for (const plan of params.acceptedPlans) {
+    for (const segment of [
+      ...plan.segments,
+      ...(plan.planeEndpointSegments ?? []),
+    ]) {
+      if (segment.layer !== targetLayer) continue
+      const radius = (segment.width + traceWidth) / 2 + clearance
+      const start = segment.start[across]
+      const delta = segment.end[across] - start
+      let from = 0
+      let to = 1
+      if (Math.abs(delta) < 1e-9) {
+        if (Math.abs(start - edge) > radius) continue
+      } else {
+        const first = (edge - radius - start) / delta
+        const last = (edge + radius - start) / delta
+        from = Math.max(0, Math.min(first, last))
+        to = Math.min(1, Math.max(first, last))
+        if (from > to) continue
+      }
+      const alongStart = segment.start[along]
+      const alongDelta = segment.end[along] - alongStart
+      const first = alongStart + from * alongDelta
+      const last = alongStart + to * alongDelta
+      blocked.push([
+        Math.min(first, last) - radius,
+        Math.max(first, last) + radius,
+      ])
+    }
+  }
+  const vias = [
+    ...params.acceptedPlans.flatMap((plan) => [
+      ...(plan.via ? [plan.via] : []),
+      ...(plan.additionalVias ?? []),
+      ...(plan.planeEndpointVia ? [plan.planeEndpointVia] : []),
+    ]),
+    ...(params.reservedVias ?? []).map((reserved) => reserved.via),
+  ]
+  for (const via of vias) {
+    if (!via.spanLayers.includes(targetLayer)) continue
+    const radius = via.diameter / 2 + traceWidth / 2 + clearance
+    const distance = Math.abs(via.center[across] - edge)
+    if (distance >= radius) continue
+    const extent = Math.sqrt(radius * radius - distance * distance)
+    blocked.push([via.center[along] - extent, via.center[along] + extent])
+  }
+  const gaps: [number, number][] = []
+  let cursor = minimum
+  for (const [from, to] of blocked.sort((a, b) => a[0] - b[0])) {
+    if (to <= cursor || from >= maximum) continue
+    if (from > cursor) gaps.push([cursor, Math.min(from, maximum)])
+    cursor = Math.max(cursor, to)
+    if (cursor >= maximum) break
+  }
+  if (cursor < maximum) gaps.push([cursor, maximum])
+  // Edge order gives deterministic, symmetric coverage without hard-coded tracks.
+  const tracks = gaps
+    .filter(([from, to]) => to - from > 1e-6)
+    .map(([from, to]) => (from + to) / 2)
+  return tracks.length <= 32
+    ? tracks
+    : Array.from(
+        { length: 32 },
+        (_, index) => tracks[Math.round((index * (tracks.length - 1)) / 31)]!,
+      )
+}

package/lib/match-angularly-ordered-local-vias.ts

@@ -0,0 +1,239 @@
+import { distance, distancePointToSegment, segmentsAreClear } from "./geometry"
+import {
+  getComponentDogboneViaSiteCandidates,
+  matchComponentDogboneViaSites,
+  type DogboneViaSiteGeometryRules,
+} from "./match-component-dogbone-via-sites"
+import type {
+  Point2D,
+  PreparedBus,
+  PreparedConnection,
+  RoutedSegment,
+} from "./types"
+
+const EPSILON = 1e-9
+const TAU = Math.PI * 2
+interface Candidate {
+  connectionIndex: number
+  point: Point2D
+  angle: number
+  sourceSegment: RoutedSegment
+  siteIndex: number
+}
+
+/** Reserve ordered source vias, then assign every remaining source via together. */
+export function matchAngularlyOrderedLocalVias(params: {
+  buses: readonly PreparedBus[]
+  busId: string
+  rules: DogboneViaSiteGeometryRules
+  maximumOrderingStates?: number
+  maximumCompleteAssignments?: number
+}): Map<number, Point2D> | null {
+  const { buses, rules } = params
+  const bus = buses.find((b) => b.busId === params.busId)
+  if (
+    !bus ||
+    bus.termination.type !== "boundary" ||
+    !bus.exitEdge ||
+    bus.connections.length < 3
+  )
+    return null
+  const maximumOrderingStates = params.maximumOrderingStates ?? 10_000
+  const maximumCompleteAssignments = params.maximumCompleteAssignments ?? 16
+  for (const [name, value] of Object.entries({
+    maximumOrderingStates,
+    maximumCompleteAssignments,
+  })) {
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new Error(`FanoutSolver: ${name} must be a positive safe integer`)
+  }
+  const center = {
+    x: (bus.componentBounds.minX + bus.componentBounds.maxX) / 2,
+    y: (bus.componentBounds.minY + bus.componentBounds.maxY) / 2,
+  }
+  const angle = (p: Point2D) => Math.atan2(p.y - center.y, p.x - center.x)
+  const targetCoordinate = (c: PreparedConnection) => {
+    const p = c.exitTargetPoint ?? c.targetPoint
+    return bus.exitEdge === "right"
+      ? p.y
+      : bus.exitEdge === "top"
+        ? -p.x
+        : bus.exitEdge === "left"
+          ? -p.y
+          : p.x
+  }
+  const ordered = bus.connections.toSorted(
+    (a, b) =>
+      targetCoordinate(a) - targetCoordinate(b) ||
+      a.connectionIndex - b.connectionIndex,
+  )
+  const sourceAngles: number[] = []
+  for (const c of ordered) {
+    if (distance(c.sourcePoint, center) < EPSILON) return null
+    let a = angle(c.sourcePoint)
+    while (a < (sourceAngles.at(-1) ?? a) - EPSILON) a += TAU
+    sourceAngles.push(a)
+  }
+  if (sourceAngles.at(-1)! - sourceAngles[0]! >= TAU - EPSILON) return null
+  const connections = new Map(
+    buses.flatMap((b) =>
+      b.connections.map((c) => [c.connectionIndex, c] as const),
+    ),
+  )
+  const orderedIndex = new Map(ordered.map((c, i) => [c.connectionIndex, i]))
+  const sites = new Map<string, number>()
+  const candidateGroups = new Map<number, Candidate[]>()
+  for (const c of connections.values())
+    candidateGroups.set(c.connectionIndex, [])
+  for (const raw of getComponentDogboneViaSiteCandidates(buses, rules)) {
+    const c = connections.get(raw.connectionIndex)!
+    const key = `${raw.point.x.toFixed(9)},${raw.point.y.toFixed(9)}`
+    if (!sites.has(key)) sites.set(key, sites.size)
+    const index = orderedIndex.get(raw.connectionIndex)
+    const sourceAngle = angle(c.sourcePoint)
+    const a =
+      index === undefined
+        ? angle(raw.point)
+        : sourceAngles[index]! +
+          Math.atan2(
+            Math.sin(angle(raw.point) - sourceAngle),
+            Math.cos(angle(raw.point) - sourceAngle),
+          )
+    candidateGroups.get(raw.connectionIndex)!.push({
+      ...raw,
+      angle: a,
+      siteIndex: sites.get(key)!,
+      sourceSegment: {
+        start: c.sourcePoint,
+        end: raw.point,
+        layer: c.sourceLayer,
+        width: rules.traceWidth,
+      },
+    })
+  }
+  const groups = [...candidateGroups.entries()].map(
+    ([connectionIndex, candidates]) => ({ connectionIndex, candidates }),
+  )
+  if (groups.some((g) => g.candidates.length === 0)) return null
+  const domains = ordered.map((c, i) =>
+    candidateGroups
+      .get(c.connectionIndex)!
+      .toSorted(
+        (a, b) =>
+          Math.abs(a.angle - sourceAngles[i]!) -
+            Math.abs(b.angle - sourceAngles[i]!) ||
+          distance(b.point, center) - distance(a.point, center),
+      ),
+  )
+  const requiredHoleSeparation = rules.viaHoleDiameter
+    ? rules.viaHoleDiameter + (rules.holeToHoleClearance ?? rules.clearance)
+    : 0
+  const requiredViaToTraceSeparation =
+    rules.viaDiameter / 2 + rules.traceWidth / 2 + rules.clearance
+  const compatible = (a: Candidate, b: Candidate) => {
+    const share =
+      rules.canShareCopper?.(a.connectionIndex, b.connectionIndex) ?? false
+    const minimumViaDistance = share
+      ? requiredHoleSeparation
+      : Math.max(requiredHoleSeparation, rules.viaDiameter + rules.clearance)
+    if (distance(a.point, b.point) < minimumViaDistance - EPSILON) return false
+    if (share) return true
+    return (
+      distancePointToSegment(
+        a.point,
+        b.sourceSegment.start,
+        b.sourceSegment.end,
+      ) >=
+        requiredViaToTraceSeparation - EPSILON &&
+      distancePointToSegment(
+        b.point,
+        a.sourceSegment.start,
+        a.sourceSegment.end,
+      ) >=
+        requiredViaToTraceSeparation - EPSILON &&
+      segmentsAreClear(a.sourceSegment, b.sourceSegment, rules.clearance)
+    )
+  }
+  const forbidden = new Map<Candidate, Set<Candidate>>()
+  for (const domain of domains)
+    for (const a of domain) {
+      const conflicts = new Set<Candidate>()
+      for (const group of groups)
+        for (const b of group.candidates) {
+          if (a.connectionIndex !== b.connectionIndex && !compatible(a, b))
+            conflicts.add(b)
+        }
+      forbidden.set(a, conflicts)
+    }
+  const chosen: Candidate[] = []
+  // A perfect matching is necessary because distinct drilled holes cannot use
+  // the same site. It is a pruning test; native matching still validates copper.
+  const canUseDistinctSiteCheck =
+    requiredHoleSeparation > EPSILON || !rules.canShareCopper
+  const remainingSitesCanMatch = () => {
+    if (!canUseDistinctSiteCheck) return true
+    const selected = new Map(
+      chosen.map((c) => [c.connectionIndex, c.siteIndex]),
+    )
+    const allowed = groups
+      .map((g) =>
+        g.candidates
+          .filter(
+            (c) =>
+              (!selected.has(c.connectionIndex) ||
+                selected.get(c.connectionIndex) === c.siteIndex) &&
+              chosen.every((a) => !forbidden.get(a)!.has(c)),
+          )
+          .map((c) => c.siteIndex),
+      )
+      .sort((a, b) => a.length - b.length)
+    if (allowed.some((d) => d.length === 0)) return false
+    const owner = new Int32Array(sites.size).fill(-1)
+    const augment = (index: number, visited: Uint8Array): boolean => {
+      for (const site of allowed[index]!) {
+        if (visited[site]) continue
+        visited[site] = 1
+        if (owner[site] === -1 || augment(owner[site]!, visited)) {
+          owner[site] = index
+          return true
+        }
+      }
+      return false
+    }
+    return allowed.every((_, i) => augment(i, new Uint8Array(sites.size)))
+  }
+  let states = 0
+  let completeAssignments = 0
+  let result: Map<number, Point2D> | null = null
+  const search = (index: number): boolean => {
+    if (++states > maximumOrderingStates) return false
+    if (index === domains.length) {
+      if (++completeAssignments > maximumCompleteAssignments) return false
+      const fixed = new Map(rules.fixedViaPointsByConnectionIndex)
+      for (const c of chosen) fixed.set(c.connectionIndex, c.point)
+      result = matchComponentDogboneViaSites(buses, {
+        ...rules,
+        fixedViaPointsByConnectionIndex: fixed,
+      })
+      return result !== null
+    }
+    for (const candidate of domains[index]!) {
+      if (
+        candidate.angle < (chosen.at(-1)?.angle ?? -Infinity) - EPSILON ||
+        chosen.some((c) => forbidden.get(c)!.has(candidate))
+      )
+        continue
+      chosen.push(candidate)
+      if (remainingSitesCanMatch() && search(index + 1)) return true
+      chosen.pop()
+      if (
+        states > maximumOrderingStates ||
+        completeAssignments >= maximumCompleteAssignments
+      )
+        break
+    }
+    return false
+  }
+  search(0)
+  return result
+}