@tscircuit/fanout-solver 0.0.48 → 0.0.50

package/lib/fanout-solver.ts

@@ -1,6 +1,6 @@
 import type { SimpleRouteJson } from "@tscircuit/capacity-autorouter"
 import { BaseSolver } from "@tscircuit/solver-utils"
-import type { GraphicsObject } from "graphics-debug"
+import { type GraphicsObject, mergeGraphics } from "graphics-debug"
 import { addViaLayerMetadataToSrj } from "./add-via-layer-metadata"
 import { getCornerBandSide, getExitEdgeForDirection } from "./boundary-exit"
 import { buildOutputSimpleRouteJson } from "./build-output"
@@ -25,11 +25,13 @@ import {
 } from "./prepare-buses"
 import {
   fanoutPlansAreClear,
+  fanoutPlansAreMutuallyClear,
   type RouteBusStaticClearanceCache,
   routeBus,
   routeBusAlternatives,
+  routeBusAlternativesSteps,
 } from "./route-bus"
-import { routeSingleLayerWithAdaptiveExits } from "./route-single-layer-adaptive-exits"
+import { routeSingleLayerWithAdaptiveExitsSteps } from "./route-single-layer-adaptive-exits"
 import { routeSingleLayerWithPushAndShove } from "./route-single-layer-push-shove"
 import type {
   AssignmentAttempt,
@@ -54,6 +56,8 @@ interface ResolvedFanoutConfig {
   compactBusTracks: boolean
   allowBlindAndBuriedVias: boolean
   allowSameNetMerges: boolean
+  densePlaneReservationBusIds: readonly string[]
+  denseUnrestrictedPlaneRoutingBusIds: readonly string[]
   singleLayerPushAndShove: boolean
   singleLayerAdaptiveExits: boolean
   borderDistribution: FanoutBorderDistribution
@@ -79,6 +83,94 @@ interface MixedTerminationState {
 
 type RoutingStrategy = "default" | "group-by-layer" | "deep-first"
 
+interface FanoutSubsolverRequest {
+  type: "subsolver"
+  solver: BaseSolver
+}
+
+type FanoutWorkYield = undefined | FanoutSubsolverRequest
+
+class FanoutWorkSolver<T> extends BaseSolver {
+  private output: T | undefined
+  private hasOutput = false
+  private nextInput: unknown
+
+  constructor(
+    private readonly solverName: string,
+    private readonly generator: Generator<unknown, T, unknown>,
+    private readonly getVisualization: () => GraphicsObject,
+    private readonly getStats: () => Record<string, unknown>,
+    private readonly getProgress: () => number,
+  ) {
+    super()
+    this.MAX_ITERATIONS = 1_000_000
+  }
+
+  override getSolverName(): string {
+    return this.solverName
+  }
+
+  override _step(): void {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step()
+      if (this.activeSubSolver.failed) {
+        this.failedSubSolvers = [
+          ...(this.failedSubSolvers ?? []),
+          this.activeSubSolver,
+        ]
+        this.error = this.activeSubSolver.error
+        this.failed = true
+        this.activeSubSolver = null
+        return
+      }
+      if (this.activeSubSolver.solved) {
+        this.nextInput = this.activeSubSolver.getOutput()
+        this.activeSubSolver = null
+      }
+      this.stats = this.getStats()
+      return
+    }
+
+    const result = this.generator.next(this.nextInput)
+    this.nextInput = undefined
+    this.stats = this.getStats()
+    if (result.done) {
+      this.output = result.value
+      this.hasOutput = true
+      this.solved = true
+      return
+    }
+    const yielded = result.value as Partial<FanoutSubsolverRequest> | undefined
+    if (yielded?.type === "subsolver" && yielded.solver instanceof BaseSolver) {
+      this.activeSubSolver = yielded.solver
+    }
+  }
+
+  computeProgress(): number {
+    return this.getProgress()
+  }
+
+  override getConstructorParams(): [] {
+    return []
+  }
+
+  override getOutput(): T {
+    if (!this.solved || !this.hasOutput) {
+      throw new Error(`${this.solverName}: output requested before completion`)
+    }
+    return this.output as T
+  }
+
+  override visualize(): GraphicsObject {
+    return this.activeSubSolver?.visualize() ?? this.getVisualization()
+  }
+}
+
+interface ActiveFanoutOperation<T> {
+  solver: FanoutWorkSolver<T>
+  onSolved: (output: T) => void
+}
+
 function resolvePositiveNumber(label: string, value: number): number {
   if (!Number.isFinite(value) || value <= 0) {
     throw new Error(
@@ -151,6 +243,9 @@ function resolveConfig(
     compactBusTracks: options.compactBusTracks ?? false,
     allowBlindAndBuriedVias: options.allowBlindAndBuriedVias ?? true,
     allowSameNetMerges: options.allowSameNetMerges ?? false,
+    densePlaneReservationBusIds: options.densePlaneReservationBusIds ?? [],
+    denseUnrestrictedPlaneRoutingBusIds:
+      options.denseUnrestrictedPlaneRoutingBusIds ?? [],
     singleLayerPushAndShove: options.singleLayerPushAndShove ?? false,
     singleLayerAdaptiveExits: options.singleLayerAdaptiveExits ?? false,
     borderDistribution,
@@ -357,8 +452,14 @@ function createInitialLayerAssignment(params: {
   buses: PreparedBus[]
   escapeLayers: string[]
   escapeLayersByBusId: Readonly<Record<string, readonly string[]>>
+  preferOrderedCoordinatedWindingLayers: boolean
 }): Readonly<Record<string, string>> {
-  const { buses, escapeLayers, escapeLayersByBusId } = params
+  const {
+    buses,
+    escapeLayers,
+    escapeLayersByBusId,
+    preferOrderedCoordinatedWindingLayers,
+  } = params
   const assignment: Record<string, string> = {}
   const directionsByComponent = new Map<string, Set<PreparedBus["direction"]>>()
   let nextViaLayerIndex = 0
@@ -394,6 +495,16 @@ function createInitialLayerAssignment(params: {
     ) {
       assignment[bus.busId] = sourceLayer
     } else if (viaLayers.length > 0) {
+      if (
+        preferOrderedCoordinatedWindingLayers &&
+        busUsesCoordinatedWinding(bus)
+      ) {
+        // Coordinated winding treats allowedLayers as an ordered preference.
+        // A global round-robin index can otherwise skip a bus's first choice
+        // just because a previous bus had a different set of legal layers.
+        assignment[bus.busId] = viaLayers[0]!
+        continue
+      }
       const componentDirections = directionsByComponent.get(bus.componentId)!
       const hasOpposingDirection =
         (componentDirections.has("left") && componentDirections.has("right")) ||
@@ -756,12 +867,12 @@ function getCandidateEscapeLayersForBus(params: {
 export class FanoutSolver extends BaseSolver {
   readonly preparedBuses: PreparedBus[]
   readonly attempts: FanoutAttemptSummary[] = []
-  readonly layerAssignments: Array<Readonly<Record<string, string>>>
+  readonly layerAssignments: Array<Readonly<Record<string, string>>> = []
   readonly config: ResolvedFanoutConfig
   private readonly routingSrj: SimpleRouteJson
-  private readonly escapeLayersByBusId: Readonly<
-    Record<string, readonly string[]>
-  >
+  private readonly escapeLayersByBusId: Record<string, readonly string[]> = {}
+  private readonly boundaryBuses: PreparedBus[]
+  private readonly fixedPlaneAssignments: Readonly<Record<string, string>>
   private readonly evaluatedAssignmentKeys = new Set<string>()
   private readonly queuedAssignmentKeys = new Set<string>()
   private readonly assignmentRepairDepthByKey = new Map<string, number>()
@@ -779,8 +890,14 @@ export class FanoutSolver extends BaseSolver {
     }
   >()
   private groupedBeamEvaluated = false
+  private routingInitialized = false
+  private nextCandidateLayerBusIndex = 0
   private nextAssignmentIndex = 0
   private nextGeneratedAssignmentIndex = 0
+  private activeOperation: ActiveFanoutOperation<unknown> | null = null
+  private inProgressPlans: FanoutRoutePlan[] = []
+  private activeRoutingVisualization: GraphicsObject | null = null
+  private activeAdaptiveVisualization: GraphicsObject | null = null
   private bestAttempt: AssignmentAttempt | null = null
   private lengthMatchingFailure: FanoutValidationIssue | null = null
   private endpointCompletion: CompleteOriginalEndpointsResult | null = null
@@ -857,56 +974,333 @@ export class FanoutSolver extends BaseSolver {
         )
       }
     }
-    const boundaryBusIds = this.preparedBuses
-      .filter((bus) => bus.termination.type === "boundary")
-      .map((bus) => bus.busId)
-    const fixedPlaneAssignments = Object.fromEntries(
+    this.boundaryBuses = this.preparedBuses.filter(
+      (bus) => bus.termination.type === "boundary",
+    )
+    this.fixedPlaneAssignments = Object.fromEntries(
       this.preparedBuses.flatMap((bus) =>
         bus.termination.type === "plane"
           ? [[bus.busId, bus.termination.layer] as const]
           : [],
       ),
     )
-    const escapeLayersByBusId = Object.fromEntries(
-      this.preparedBuses.flatMap((bus) => {
-        if (bus.termination.type === "plane") return []
-        return [
-          [
-            bus.busId,
-            getCandidateEscapeLayersForBus({
-              bus,
-              srj: this.routingSrj,
-              config: this.config,
-              staticClearanceCache: this.routeStaticClearanceCache,
-            }),
-          ] as const,
-        ]
-      }),
-    )
-    this.escapeLayersByBusId = escapeLayersByBusId
+    const workUnitsPerAssignment = this.preparedBuses.length * 3 + 8
+    const estimatedWorkUnitCount =
+      this.boundaryBuses.length +
+      1 +
+      this.config.maxLayerCombinations * workUnitsPerAssignment +
+      this.preparedBuses.length * 2 +
+      20
+    this.MAX_ITERATIONS = Math.max(10_000, estimatedWorkUnitCount)
+  }
+
+  override getSolverName(): string {
+    return "FanoutSolver"
+  }
+
+  private stepRoutingInitialization(): void {
+    const bus = this.boundaryBuses[this.nextCandidateLayerBusIndex]
+    if (bus) {
+      this.escapeLayersByBusId[bus.busId] = getCandidateEscapeLayersForBus({
+        bus,
+        srj: this.routingSrj,
+        config: this.config,
+        staticClearanceCache: this.routeStaticClearanceCache,
+      })
+      this.nextCandidateLayerBusIndex++
+      this.stats = {
+        phase: "discover-candidate-layers",
+        bus: bus.busId,
+        busIndex: this.nextCandidateLayerBusIndex,
+        busCount: this.boundaryBuses.length,
+      }
+      return
+    }
+
     const generatedAssignments = generateLayerAssignments({
-      busIds: boundaryBusIds,
+      busIds: this.boundaryBuses.map((candidate) => candidate.busId),
       layers: this.config.escapeLayers,
-      layersByBusId: escapeLayersByBusId,
+      layersByBusId: this.escapeLayersByBusId,
       maxAssignments: this.config.maxLayerCombinations,
     }).map((assignment) => ({
       ...assignment,
-      ...fixedPlaneAssignments,
+      ...this.fixedPlaneAssignments,
     }))
-    this.layerAssignments = prioritizeLayerAssignment({
-      initialAssignment: createInitialLayerAssignment({
-        buses: this.preparedBuses,
-        escapeLayers: this.config.escapeLayers,
-        escapeLayersByBusId,
+    this.layerAssignments.push(
+      ...prioritizeLayerAssignment({
+        initialAssignment: createInitialLayerAssignment({
+          buses: this.preparedBuses,
+          escapeLayers: this.config.escapeLayers,
+          escapeLayersByBusId: this.escapeLayersByBusId,
+          preferOrderedCoordinatedWindingLayers:
+            this.config.densePlaneReservationBusIds.length > 0 ||
+            this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0,
+        }),
+        generatedAssignments,
+        maxAssignments: this.config.maxLayerCombinations,
       }),
-      generatedAssignments,
-      maxAssignments: this.config.maxLayerCombinations,
-    })
-    this.MAX_ITERATIONS = this.config.maxLayerCombinations + 2
+    )
+    this.routingInitialized = true
+    this.stats = {
+      phase: "prepare-layer-assignments",
+      assignmentCount: this.layerAssignments.length,
+    }
   }
 
-  override getSolverName(): string {
-    return "FanoutSolver"
+  private *initializeRoutingSteps(): Generator<FanoutWorkYield, void, unknown> {
+    while (!this.routingInitialized) {
+      this.stepRoutingInitialization()
+      if (!this.routingInitialized) yield
+    }
+  }
+
+  private setInProgressPlans(params: {
+    phase: string
+    plans: readonly FanoutRoutePlan[]
+    strategy?: RoutingStrategy | "grouped-beam"
+    unitIndex?: number
+    unitCount?: number
+    busId?: string
+  }): void {
+    this.inProgressPlans = [...params.plans]
+    this.stats = {
+      ...this.stats,
+      phase: params.phase,
+      ...(params.strategy ? { routingStrategy: params.strategy } : {}),
+      ...(params.unitIndex !== undefined ? { workUnit: params.unitIndex } : {}),
+      ...(params.unitCount !== undefined
+        ? { workUnitCount: params.unitCount }
+        : {}),
+      ...(params.busId ? { bus: params.busId } : {}),
+      routedConnections: `${params.plans.length}/${this.inputSrj.connections.length}`,
+    }
+  }
+
+  private visualizeCurrentState(): GraphicsObject {
+    const visualizedSrj =
+      this.endpointCompletion?.simpleRouteJson ??
+      (!this.solved && !this.failed && this.inProgressPlans.length > 0
+        ? buildOutputSimpleRouteJson({
+            inputSrj: this.inputSrj,
+            plans: this.inProgressPlans,
+            layerNames: this.config.layerNames,
+          })
+        : undefined) ??
+      this.bestAttempt?.outputSrj ??
+      this.inputSrj
+    return visualizeSimpleRouteJson(visualizedSrj)
+  }
+
+  private visualizeWorkState(solverName: string): GraphicsObject {
+    const base = this.visualizeCurrentState()
+    const boundary =
+      this.preparedBuses[0]?.sharedBoundary ?? this.inputSrj.bounds
+    const activeBusId =
+      typeof this.stats.bus === "string" ? this.stats.bus : undefined
+    const activeBus = activeBusId
+      ? this.preparedBuses.find((bus) => bus.busId === activeBusId)
+      : undefined
+    const width = boundary.maxX - boundary.minX
+    const height = boundary.maxY - boundary.minY
+    const annotationSize = Math.max(Math.min(width, height) * 0.025, 0.25)
+    const phase =
+      typeof this.stats.phase === "string" ? this.stats.phase : "starting"
+    const detail = [
+      typeof this.stats.routeConnection === "string"
+        ? `connection ${this.stats.routeConnection}`
+        : undefined,
+      typeof this.stats.searchBatch === "number"
+        ? `batch ${this.stats.searchBatch}`
+        : undefined,
+      typeof this.stats.expandedStates === "number"
+        ? `${this.stats.expandedStates.toLocaleString()} states`
+        : undefined,
+    ]
+      .filter(Boolean)
+      .join(" · ")
+    const title = `${solverName}: ${phase}`
+    return {
+      ...mergeGraphics(base, {
+        rects: [
+          {
+            center: {
+              x: (boundary.minX + boundary.maxX) / 2,
+              y: (boundary.minY + boundary.maxY) / 2,
+            },
+            width,
+            height,
+            fill: "rgba(0, 0, 0, 0)",
+            stroke: "rgba(14, 165, 233, 0.8)",
+            label: `${solverName} working boundary`,
+          },
+        ],
+        circles: (activeBus?.connections ?? []).map((connection) => ({
+          center: connection.sourcePoint,
+          radius: Math.max(
+            annotationSize,
+            Math.min(
+              connection.sourceObstacle.width,
+              connection.sourceObstacle.height,
+            ) * 0.6,
+          ),
+          fill: "rgba(250, 204, 21, 0.25)",
+          stroke: "#f59e0b",
+          label: `active bus ${activeBusId}: ${connection.connection.name}`,
+        })),
+        texts: [
+          {
+            x: boundary.minX,
+            y: boundary.maxY + annotationSize * 2,
+            text: `${solverName} · ${phase}${detail ? ` · ${detail}` : ""}`,
+            color: "#0f172a",
+            fontSize: annotationSize * 1.5,
+            anchorSide: "bottom_left",
+          },
+        ],
+      }),
+      title,
+    }
+  }
+
+  private visualizeBoundaryRoutingState(): GraphicsObject {
+    if (!this.activeRoutingVisualization) {
+      return this.visualizeWorkState("BoundaryBusRoutingSolver")
+    }
+    return {
+      ...mergeGraphics(
+        this.visualizeCurrentState(),
+        this.activeRoutingVisualization,
+      ),
+      title: this.activeRoutingVisualization.title,
+    }
+  }
+
+  private visualizeAdaptiveRoutingState(): GraphicsObject {
+    if (this.activeAdaptiveVisualization) {
+      return this.activeAdaptiveVisualization
+    }
+    const boundary =
+      this.preparedBuses[0]?.sharedBoundary ?? this.inputSrj.bounds
+    const width = boundary.maxX - boundary.minX
+    const height = boundary.maxY - boundary.minY
+    const annotationSize = Math.max(Math.min(width, height) * 0.02, 0.2)
+    return {
+      title: "SingleLayerAdaptiveExitSolver: preparing flow grid",
+      rects: [
+        {
+          center: {
+            x: (boundary.minX + boundary.maxX) / 2,
+            y: (boundary.minY + boundary.maxY) / 2,
+          },
+          width,
+          height,
+          fill: "rgba(0, 0, 0, 0)",
+          stroke: "rgba(14, 165, 233, 0.9)",
+          label: "adaptive flow grid boundary",
+        },
+      ],
+      points: this.preparedBuses.flatMap((bus) =>
+        bus.connections.map((connection) => ({
+          ...connection.sourcePoint,
+          color: "#f97316",
+          label: "adaptive route source",
+        })),
+      ),
+      texts: [
+        {
+          x: boundary.minX,
+          y: boundary.maxY + annotationSize * 2,
+          text: "preparing adaptive flow grid",
+          color: "#0f172a",
+          fontSize: annotationSize * 1.5,
+          anchorSide: "bottom_left",
+        },
+      ],
+    }
+  }
+
+  private startOperation<T>(params: {
+    name: string
+    generator: Generator<unknown, T, unknown>
+    onSolved: (output: T) => void
+    getProgress?: () => number
+  }): void {
+    const solver = this.createWorkSolver(
+      params.name,
+      params.generator,
+      params.getProgress,
+    )
+    this.activeOperation = {
+      solver,
+      onSolved: params.onSolved,
+    } as ActiveFanoutOperation<unknown>
+    this.activeSubSolver = solver
+  }
+
+  private createWorkSolver<T>(
+    name: string,
+    generator: Generator<unknown, T, unknown>,
+    getProgress?: () => number,
+    getVisualization?: () => GraphicsObject,
+  ): FanoutWorkSolver<T> {
+    return new FanoutWorkSolver(
+      name,
+      generator,
+      getVisualization ?? (() => this.visualizeWorkState(name)),
+      () => ({ ...this.stats }),
+      getProgress ?? (() => 0),
+    )
+  }
+
+  private *routeBusAlternativesWorkSteps(
+    params: Parameters<typeof routeBusAlternativesSteps>[0],
+    maximumAlternatives: number,
+  ): Generator<FanoutWorkYield, FanoutRoutePlan[][], unknown> {
+    const steps = routeBusAlternativesSteps(params, maximumAlternatives, true)
+    let result = steps.next()
+    while (!result.done) {
+      const { winding } = result.value
+      if (winding.visualization) {
+        this.activeRoutingVisualization = winding.visualization
+      }
+      this.stats = {
+        ...this.stats,
+        phase: "route-boundary-bus-connection",
+        bus: result.value.busId,
+        targetLayer: result.value.targetLayer,
+        routeOrderAttempt: winding.routeOrderAttempt,
+        routeConnection: `${winding.connectionIndex + 1}/${winding.connectionCount}`,
+        connection: winding.connectionName,
+        searchBatch: winding.searchBatch,
+        expandedStates: winding.expandedStateCount,
+        connectionComplete: winding.connectionComplete,
+      }
+      yield
+      result = steps.next()
+    }
+    return result.value
+  }
+
+  private stepActiveOperation(): void {
+    const operation = this.activeOperation
+    if (!operation) return
+    operation.solver.step()
+    if (operation.solver.failed) {
+      this.failedSubSolvers = [
+        ...(this.failedSubSolvers ?? []),
+        operation.solver,
+      ]
+      this.error = operation.solver.error
+      this.failed = true
+      this.activeOperation = null
+      this.activeSubSolver = null
+      return
+    }
+    if (!operation.solver.solved) return
+    const output = operation.solver.getOutput()
+    this.activeOperation = null
+    this.activeSubSolver = null
+    operation.onSolved(output)
   }
 
   private completeBestAttemptEndpoints(): void {
@@ -983,15 +1377,43 @@ export class FanoutSolver extends BaseSolver {
    * dogbones. This is intentionally bounded independently of the number of
    * plane drops so dense power fields cannot explode the general beam search.
    */
-  private routeDenseThroughAllMixedTerminations(params: {
+  private *routeDenseThroughAllMixedTerminationSteps(params: {
     busLayerAssignments: Readonly<Record<string, string>>
     busesInRoutingOrder: readonly PreparedBus[]
-  }): MixedTerminationState | null {
+  }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
     if (this.config.allowBlindAndBuriedVias) return null
+    const debugDense = (...values: unknown[]) => {
+      if (process.env.FANOUT_DEBUG_DENSE === "1") {
+        if (
+          process.env.FANOUT_DEBUG_DENSE_SUMMARY === "1" &&
+          ![
+            "start",
+            "plane-match:preflight-failed",
+            "plane-match:incremental-complete",
+            "plane-match:incremental-failed",
+            "plane-route:alternate-candidate-counts",
+            "plane-route:alternate-search",
+            "plane-route:promote-failed",
+            "plane-route:alternate-choice",
+            "plane-route:promote-zero-candidates",
+            "length-match:complete",
+            "length-match:start",
+            "plane-route:failed",
+            "dense-validation",
+          ].includes(String(values[0]))
+        ) {
+          return
+        }
+        console.error("dense:", ...values)
+      }
+    }
 
     const unsortedBoundaryBuses = params.busesInRoutingOrder.filter(
       (bus) => bus.termination.type === "boundary",
     )
+    const useConfiguredDensePlaneRouting =
+      this.config.densePlaneReservationBusIds.length > 0 ||
+      this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0
     const useJointBoundaryViaReservation = shouldUseJointBoundaryViaReservation(
       unsortedBoundaryBuses.map((bus) => bus.connections.length),
     )
@@ -1013,84 +1435,181 @@ export class FanoutSolver extends BaseSolver {
           ]),
         )
       : null
-    const boundaryBuses = unsortedBoundaryBuses.toSorted((first, second) => {
-      // Reserve the dense escape field for the widest buses first. Small
-      // control groups can usually route around their copper, while routing
-      // a two-line corner bus first can consume a critical channel needed by
-      // an eight-line winding bus and force the expensive fallback search.
-      if (useJointBoundaryViaReservation) {
-        const connectionCountDifference =
-          second.connections.length - first.connections.length
-        if (connectionCountDifference !== 0) return connectionCountDifference
-      }
-      const firstLayer = params.busLayerAssignments[first.busId]
-      const secondLayer = params.busLayerAssignments[second.busId]
-      const firstPairRoutingPriority = pairRoutingPriorityKeyByBusId?.get(
-        first.busId,
-      )
-      const secondPairRoutingPriority = pairRoutingPriorityKeyByBusId?.get(
-        second.busId,
-      )
-      if (
-        firstPairRoutingPriority !== undefined &&
-        secondPairRoutingPriority !== undefined &&
-        firstPairRoutingPriority !== secondPairRoutingPriority
-      ) {
-        // The third pair can be fenced off by two earlier pair windings. Let
-        // the pair with the shortest farthest-lane boundary reach claim its
-        // channel first without relying on caller-specific bus identifiers.
-        return firstPairRoutingPriority - secondPairRoutingPriority
+    const wideBoundaryBuses = unsortedBoundaryBuses.filter(
+      (bus) => bus.connections.length >= 8,
+    )
+    const hasThreeWideBoundaryBuses =
+      useConfiguredDensePlaneRouting && wideBoundaryBuses.length === 3
+    const getBoundaryTargetSpan = (bus: PreparedBus) => {
+      const coordinates = bus.connections.map((connection) => {
+        const target = connection.exitTargetPoint ?? connection.targetPoint
+        return bus.exitEdge === "top" || bus.exitEdge === "bottom"
+          ? target.x
+          : target.y
+      })
+      return {
+        minimum: Math.min(...coordinates),
+        maximum: Math.max(...coordinates),
       }
-      const cornerBandDifference =
-        Number(
-          Boolean(getCornerBandSide(second.exitEdge, second.preferredExit)),
-        ) -
-        Number(Boolean(getCornerBandSide(first.exitEdge, first.preferredExit)))
-      if (cornerBandDifference !== 0) return cornerBandDifference
-      const firstIsCorner = Boolean(
-        getCornerBandSide(first.exitEdge, first.preferredExit),
-      )
-      if (!firstIsCorner) {
-        const getSourceSpan = (bus: PreparedBus): number => {
-          const xCoordinates = bus.connections.map(
-            (connection) => connection.sourcePoint.x,
-          )
-          const yCoordinates = bus.connections.map(
-            (connection) => connection.sourcePoint.y,
-          )
-          return (
-            Math.max(...xCoordinates) -
-            Math.min(...xCoordinates) +
-            Math.max(...yCoordinates) -
-            Math.min(...yCoordinates)
+    }
+    const narrowBusOverlapsWideTargetSpan = (bus: PreparedBus): boolean => {
+      if (bus.connections.length >= 8) return false
+      const span = getBoundaryTargetSpan(bus)
+      return wideBoundaryBuses.some((wideBus) => {
+        if (wideBus.exitEdge !== bus.exitEdge) return false
+        const wideSpan = getBoundaryTargetSpan(wideBus)
+        return (
+          span.maximum >= wideSpan.minimum - 1e-9 &&
+          span.minimum <= wideSpan.maximum + 1e-9
+        )
+      })
+    }
+    const getContainingWideSourceField = (
+      bus: PreparedBus,
+    ): PreparedBus | undefined => {
+      if (bus.connections.length >= 8) return undefined
+      return wideBoundaryBuses.find((wideBus) => {
+        const wideXCoordinates = wideBus.connections.map(
+          (connection) => connection.sourcePoint.x,
+        )
+        const wideYCoordinates = wideBus.connections.map(
+          (connection) => connection.sourcePoint.y,
+        )
+        const minimumX = Math.min(...wideXCoordinates)
+        const maximumX = Math.max(...wideXCoordinates)
+        const minimumY = Math.min(...wideYCoordinates)
+        const maximumY = Math.max(...wideYCoordinates)
+        return bus.connections.every(
+          (connection) =>
+            connection.sourcePoint.x >= minimumX - 1e-9 &&
+            connection.sourcePoint.x <= maximumX + 1e-9 &&
+            connection.sourcePoint.y >= minimumY - 1e-9 &&
+            connection.sourcePoint.y <= maximumY + 1e-9,
+        )
+      })
+    }
+    const narrowBusIsEmbeddedInWideSourceField = (bus: PreparedBus): boolean =>
+      Boolean(getContainingWideSourceField(bus))
+    const getThreeWideRoutingPriority = (bus: PreparedBus): number =>
+      narrowBusOverlapsWideTargetSpan(bus) &&
+      !narrowBusIsEmbeddedInWideSourceField(bus)
+        ? 0
+        : bus.connections.length >= 8
+          ? 1
+          : bus.connections.length > 1
+            ? 2
+            : 3
+    const initiallySortedBoundaryBuses = unsortedBoundaryBuses.toSorted(
+      (first, second) => {
+        // Reserve the dense escape field for the widest buses first. Small
+        // control groups can usually route around their copper, while routing
+        // a two-line corner bus first can consume a critical channel needed by
+        // an eight-line winding bus and force the expensive fallback search.
+        if (useJointBoundaryViaReservation || wideBoundaryBuses.length > 0) {
+          if (hasThreeWideBoundaryBuses) {
+            const threeWidePriorityDifference =
+              getThreeWideRoutingPriority(first) -
+              getThreeWideRoutingPriority(second)
+            if (threeWidePriorityDifference !== 0) {
+              return threeWidePriorityDifference
+            }
+          }
+          const connectionCountDifference =
+            unsortedBoundaryBuses.length === 2 &&
+            Math.max(
+              ...unsortedBoundaryBuses.map((bus) => bus.connections.length),
+            ) >= 8
+              ? first.connections.length - second.connections.length
+              : second.connections.length - first.connections.length
+          if (connectionCountDifference !== 0) return connectionCountDifference
+        }
+        const firstLayer = params.busLayerAssignments[first.busId]
+        const secondLayer = params.busLayerAssignments[second.busId]
+        const firstPairRoutingPriority = pairRoutingPriorityKeyByBusId?.get(
+          first.busId,
+        )
+        const secondPairRoutingPriority = pairRoutingPriorityKeyByBusId?.get(
+          second.busId,
+        )
+        if (
+          firstPairRoutingPriority !== undefined &&
+          secondPairRoutingPriority !== undefined &&
+          firstPairRoutingPriority !== secondPairRoutingPriority
+        ) {
+          // The third pair can be fenced off by two earlier pair windings. Let
+          // the pair with the shortest farthest-lane boundary reach claim its
+          // channel first without relying on caller-specific bus identifiers.
+          return firstPairRoutingPriority - secondPairRoutingPriority
+        }
+        const cornerBandDifference =
+          Number(
+            Boolean(getCornerBandSide(second.exitEdge, second.preferredExit)),
+          ) -
+          Number(
+            Boolean(getCornerBandSide(first.exitEdge, first.preferredExit)),
           )
+        if (cornerBandDifference !== 0) return cornerBandDifference
+        const firstIsCorner = Boolean(
+          getCornerBandSide(first.exitEdge, first.preferredExit),
+        )
+        if (!firstIsCorner) {
+          const getSourceSpan = (bus: PreparedBus): number => {
+            const xCoordinates = bus.connections.map(
+              (connection) => connection.sourcePoint.x,
+            )
+            const yCoordinates = bus.connections.map(
+              (connection) => connection.sourcePoint.y,
+            )
+            return (
+              Math.max(...xCoordinates) -
+              Math.min(...xCoordinates) +
+              Math.max(...yCoordinates) -
+              Math.min(...yCoordinates)
+            )
+          }
+          const sourceSpanDifference =
+            getSourceSpan(second) - getSourceSpan(first)
+          if (Math.abs(sourceSpanDifference) > 1e-9) {
+            return sourceSpanDifference
+          }
         }
-        const sourceSpanDifference =
-          getSourceSpan(second) - getSourceSpan(first)
-        if (Math.abs(sourceSpanDifference) > 1e-9) {
-          return sourceSpanDifference
+        const layerDifference =
+          this.config.layerNames.indexOf(firstLayer ?? "") -
+          this.config.layerNames.indexOf(secondLayer ?? "")
+        if (layerDifference !== 0) return -layerDifference
+        if (
+          unsortedBoundaryBuses.length !== 6 &&
+          unsortedBoundaryBuses.length !== 7 &&
+          unsortedBoundaryBuses.length !== 8 &&
+          unsortedBoundaryBuses.length !== 9
+        ) {
+          return 0
         }
-      }
-      const layerDifference =
-        this.config.layerNames.indexOf(firstLayer ?? "") -
-        this.config.layerNames.indexOf(secondLayer ?? "")
-      if (layerDifference !== 0) return -layerDifference
-      if (
-        unsortedBoundaryBuses.length !== 6 &&
-        unsortedBoundaryBuses.length !== 7 &&
-        unsortedBoundaryBuses.length !== 8 &&
-        unsortedBoundaryBuses.length !== 9
-      ) {
-        return 0
-      }
-      // The general routing order can differ across the two components as a
-      // function of local pad geometry. Keep otherwise-equivalent corner buses
-      // in one deterministic order for the six- through nine-bus paths so their
-      // boundary lanes do not swap between the two ends of a direct
-      // interconnect. Leave the released four- and five-bus tie behavior
-      // unchanged.
-      return first.busId.localeCompare(second.busId)
-    })
+        // The general routing order can differ across the two components as a
+        // function of local pad geometry. Keep otherwise-equivalent corner buses
+        // in one deterministic order for the six- through nine-bus paths so their
+        // boundary lanes do not swap between the two ends of a direct
+        // interconnect. Leave the released four- and five-bus tie behavior
+        // unchanged.
+        return first.busId.localeCompare(second.busId)
+      },
+    )
+    const debugBoundaryOrder =
+      process.env.FANOUT_DEBUG_BOUNDARY_ORDER?.split(",") ??
+      (process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS
+        ? [process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS]
+        : [])
+    const boundaryBuses =
+      debugBoundaryOrder.length > 0
+        ? initiallySortedBoundaryBuses.toSorted((first, second) => {
+            const firstIndex = debugBoundaryOrder.indexOf(first.busId)
+            const secondIndex = debugBoundaryOrder.indexOf(second.busId)
+            return (
+              (firstIndex < 0 ? Number.POSITIVE_INFINITY : firstIndex) -
+              (secondIndex < 0 ? Number.POSITIVE_INFINITY : secondIndex)
+            )
+          })
+        : initiallySortedBoundaryBuses
     // Preserve the caller/input order for the dense singleton fill. The
     // general routing sort is useful for heterogeneous buses, but ordering a
     // regular BGA power field by obstacle depth creates artificial local
@@ -1099,6 +1618,43 @@ export class FanoutSolver extends BaseSolver {
     const planeBuses = this.preparedBuses.filter(
       (bus) => bus.termination.type === "plane",
     )
+    const denseAdditionalObstacles = useConfiguredDensePlaneRouting
+      ? this.routingSrj.obstacles
+      : undefined
+    const initialPlaneReservationCount = Number.parseInt(
+      process.env.FANOUT_INITIAL_PLANE_RESERVATIONS ?? "8",
+      10,
+    )
+    const debugInitialPlaneIndices =
+      process.env.FANOUT_DEBUG_INITIAL_PLANE_INDICES?.split(",").map(
+        (index) => Number(index) - 1,
+      )
+    const debugInitialPlaneBusIds =
+      process.env.FANOUT_DEBUG_INITIAL_PLANE_BUS_IDS?.split(",")
+    let activeBoundaryReservationPlaneBuses = debugInitialPlaneBusIds
+      ? planeBuses.filter((bus) => debugInitialPlaneBusIds.includes(bus.busId))
+      : debugInitialPlaneIndices
+        ? debugInitialPlaneIndices.flatMap((index) =>
+            planeBuses[index] ? [planeBuses[index]!] : [],
+          )
+        : this.config.densePlaneReservationBusIds.length > 0
+          ? planeBuses.filter((bus) =>
+              this.config.densePlaneReservationBusIds.includes(bus.busId),
+            )
+          : useConfiguredDensePlaneRouting
+            ? planeBuses.slice(
+                0,
+                Number.isFinite(initialPlaneReservationCount)
+                  ? initialPlaneReservationCount
+                  : 8,
+              )
+            : planeBuses
+    debugDense(
+      "start",
+      boundaryBuses.map((bus) => `${bus.busId}:${bus.connections.length}`),
+      `planes:${planeBuses.length}`,
+      `joint:${useJointBoundaryViaReservation}`,
+    )
     if (
       boundaryBuses.length === 0 ||
       boundaryBuses.length > 9 ||
@@ -1129,18 +1685,40 @@ export class FanoutSolver extends BaseSolver {
       singletonBoundaryBusCount > 1 &&
       shouldDeferSingletonBoundaryViaReservation(boundaryBusConnectionCounts)
     const preferredBoundaryPerpendicularSideByBusId = new Map(
-      boundaryBuses.map((bus) => [bus.busId, 1 as const]),
+      boundaryBuses.map((bus) => [
+        bus.busId,
+        hasThreeWideBoundaryBuses &&
+        bus.connections.length < 8 &&
+        narrowBusIsEmbeddedInWideSourceField(bus)
+          ? (-1 as const)
+          : (1 as const),
+      ]),
     )
     const preferBoundaryOutwardByBusId = new Map(
       boundaryBuses.map((bus) => [
         bus.busId,
-        useGeometryAwareSingletonOutwardPreference &&
-        bus.connections.length === 1 &&
-        getCornerBandSide(bus.exitEdge, bus.preferredExit)
-          ? getDenseSingletonBoundaryGeometry(bus).targetProjection > 0
-          : getExitEdgeForDirection(bus.direction) !== bus.exitEdge,
+        bus.connections.length === 1
+          ? hasThreeWideBoundaryBuses &&
+            narrowBusIsEmbeddedInWideSourceField(bus)
+            ? true
+            : useGeometryAwareSingletonOutwardPreference &&
+                getCornerBandSide(bus.exitEdge, bus.preferredExit)
+              ? getDenseSingletonBoundaryGeometry(bus).targetProjection > 0
+              : getExitEdgeForDirection(bus.direction) !== bus.exitEdge
+          : bus.exitEdge === "top" && bus.connections.length >= 8
+            ? false
+            : getExitEdgeForDirection(bus.direction) !== bus.exitEdge,
       ]),
     )
+    const debugFlippedBoundaryBus = process.env.FANOUT_DEBUG_FLIP_BOUNDARY_BUS
+    if (debugFlippedBoundaryBus) {
+      preferredBoundaryPerpendicularSideByBusId.set(debugFlippedBoundaryBus, -1)
+    }
+    const debugOutwardBoundaryBus =
+      process.env.FANOUT_DEBUG_OUTWARD_BOUNDARY_BUS
+    if (debugOutwardBoundaryBus) {
+      preferBoundaryOutwardByBusId.set(debugOutwardBoundaryBus, true)
+    }
     const canShareCopper = (
       firstConnectionIndex: number,
       secondConnectionIndex: number,
@@ -1176,6 +1754,7 @@ export class FanoutSolver extends BaseSolver {
       (bus) => bus.connections.length === 1,
     )
     const singletonDeferralCandidates =
+      !hasThreeWideBoundaryBuses &&
       shouldDeferSingletonBoundaryViaReservation(boundaryBusConnectionCounts)
         ? singletonBoundaryBuses
             .toSorted(
@@ -1190,8 +1769,8 @@ export class FanoutSolver extends BaseSolver {
               ),
             )
         : []
-    const leadingWideSingletonBuses =
-      boundaryBuses.length === 9
+    const multiLayerLeadingSingletonBuses =
+      boundaryBuses.length === 8 || boundaryBuses.length === 9
         ? singletonDeferralCandidates.filter((singletonBus) => {
             const singletonTargetLayer =
               params.busLayerAssignments[singletonBus.busId]
@@ -1205,6 +1784,53 @@ export class FanoutSolver extends BaseSolver {
             )
           })
         : []
+    const throughAllLeadingSingletonBuses = hasThreeWideBoundaryBuses
+      ? singletonBoundaryBuses.filter((singletonBus) => {
+          const containingWideBus = getContainingWideSourceField(singletonBus)
+          const singletonTargetLayer =
+            params.busLayerAssignments[singletonBus.busId]
+          const containingWideLayers =
+            containingWideBus?.routableEscapeLayers ??
+            containingWideBus?.allowedLayers ??
+            []
+          return Boolean(
+            containingWideBus &&
+              singletonTargetLayer &&
+              !containingWideLayers.includes(singletonTargetLayer),
+          )
+        })
+      : []
+    const throughAllLeadingCompanionBuses =
+      throughAllLeadingSingletonBuses.flatMap((singletonBus) => {
+        const containingWideBus = getContainingWideSourceField(singletonBus)
+        const singletonTargetLayer =
+          params.busLayerAssignments[singletonBus.busId]
+        return boundaryBuses.filter(
+          (candidate) =>
+            candidate.connections.length > 1 &&
+            candidate.connections.length < 8 &&
+            candidate.direction === singletonBus.direction &&
+            params.busLayerAssignments[candidate.busId] ===
+              singletonTargetLayer &&
+            getContainingWideSourceField(candidate) === containingWideBus,
+        )
+      })
+    const throughAllLeadingBuses =
+      process.env.FANOUT_DEBUG_DISABLE_LEADING_NARROW === "1"
+        ? []
+        : throughAllLeadingSingletonBuses.flatMap((singletonBus) => [
+            singletonBus,
+            ...throughAllLeadingCompanionBuses.filter(
+              (candidate) =>
+                candidate.direction === singletonBus.direction &&
+                params.busLayerAssignments[candidate.busId] ===
+                  params.busLayerAssignments[singletonBus.busId],
+            ),
+          ])
+    const leadingWideSingletonBuses = [
+      ...multiLayerLeadingSingletonBuses,
+      ...throughAllLeadingBuses,
+    ].filter((bus, index, buses) => buses.indexOf(bus) === index)
     const leadingLaneCountByWideCornerBand = new Map<string, number>()
     if (boundaryBuses.length === 9 && leadingWideSingletonBuses.length > 0) {
       for (const bus of leadingWideSingletonBuses) {
@@ -1229,11 +1855,22 @@ export class FanoutSolver extends BaseSolver {
         )
       }
     }
-    const viaProvisionalSingletonBusSet = new Set(
-      singletonDeferralCandidates.filter(
+    const viaProvisionalBoundaryBusSet = new Set([
+      ...(process.env.FANOUT_DEBUG_PROVISIONAL_NARROW === "1"
+        ? boundaryBuses.filter((bus) => bus.connections.length < 8)
+        : []),
+      ...singletonDeferralCandidates.filter(
         (bus) => !leadingWideSingletonBuses.includes(bus),
       ),
-    )
+      ...(hasThreeWideBoundaryBuses
+        ? boundaryBuses.filter(
+            (bus) =>
+              bus.connections.length === 2 &&
+              !narrowBusOverlapsWideTargetSpan(bus) &&
+              !leadingWideSingletonBuses.includes(bus),
+          )
+        : []),
+    ])
     const getCornerBandTargetTrackOffset = (bus: PreparedBus): number => {
       const side = getCornerBandSide(bus.exitEdge, bus.preferredExit)
       if (!bus.exitEdge || !side) return 0
@@ -1247,11 +1884,14 @@ export class FanoutSolver extends BaseSolver {
       })
     }
     const initiallyMatchedBoundaryBuses = boundaryBuses.filter(
-      (bus) => !viaProvisionalSingletonBusSet.has(bus),
+      (bus) => !viaProvisionalBoundaryBusSet.has(bus),
     )
     const jointViaPoints = useJointBoundaryViaReservation
       ? matchComponentDogboneViaSites(
-          [...planeBuses, ...initiallyMatchedBoundaryBuses],
+          [
+            ...activeBoundaryReservationPlaneBuses,
+            ...initiallyMatchedBoundaryBuses,
+          ],
           {
             viaDiameter: this.config.viaDiameter,
             viaHoleDiameter: this.config.viaHoleDiameter,
@@ -1260,28 +1900,133 @@ export class FanoutSolver extends BaseSolver {
             maximumSearchStates: 100_000,
             preferredBoundaryPerpendicularSideByBusId,
             preferBoundaryOutwardByBusId,
+            additionalObstacles: denseAdditionalObstacles,
+            preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
             canShareCopper,
           },
         )
       : null
-    const seedViaPoints =
+    let seedViaPoints =
       jointViaPoints ??
-      matchComponentDogboneViaSites([...planeBuses, boundaryBuses[0]!], {
-        viaDiameter: this.config.viaDiameter,
-        viaHoleDiameter: this.config.viaHoleDiameter,
-        traceWidth: this.config.traceWidth,
-        clearance: this.config.clearance,
-        maximumSearchStates: 20_000,
-        preferredBoundaryPerpendicularSideByBusId,
-        preferBoundaryOutwardByBusId,
-        canShareCopper,
-      })
+      matchComponentDogboneViaSites(
+        [...activeBoundaryReservationPlaneBuses, boundaryBuses[0]!],
+        {
+          viaDiameter: this.config.viaDiameter,
+          viaHoleDiameter: this.config.viaHoleDiameter,
+          traceWidth: this.config.traceWidth,
+          clearance: this.config.clearance,
+          maximumSearchStates: 20_000,
+          preferredBoundaryPerpendicularSideByBusId,
+          preferBoundaryOutwardByBusId,
+          additionalObstacles: denseAdditionalObstacles,
+          preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+          canShareCopper,
+        },
+      )
+    const debugFixedVias = process.env.FANOUT_DEBUG_FIXED_VIAS
+    if (seedViaPoints && debugFixedVias) {
+      seedViaPoints = new Map(seedViaPoints)
+      for (const entry of debugFixedVias.split(",")) {
+        const parts = entry.split(":")
+        const rawY = parts.pop()
+        const rawX = parts.pop()
+        const connectionName = parts.join(":")
+        const connectionIndex = [...connectionNameByIndex].find(
+          ([, name]) => name === connectionName,
+        )?.[0]
+        const x = Number(rawX)
+        const y = Number(rawY)
+        if (
+          connectionIndex !== undefined &&
+          Number.isFinite(x) &&
+          Number.isFinite(y)
+        ) {
+          seedViaPoints.set(connectionIndex, { x, y })
+        }
+      }
+    }
+    const debugStagedPlaneBuses = process.env.FANOUT_DEBUG_STAGED_PLANE_BUS_IDS
+      ? planeBuses.filter((bus) =>
+          process.env
+            .FANOUT_DEBUG_STAGED_PLANE_BUS_IDS!.split(",")
+            .includes(bus.busId),
+        )
+      : (process.env.FANOUT_DEBUG_STAGED_PLANE_INDICES?.split(",").flatMap(
+          (index) =>
+            planeBuses[Number(index) - 1]
+              ? [planeBuses[Number(index) - 1]!]
+              : [],
+        ) ?? [])
+    if (seedViaPoints && debugStagedPlaneBuses.length > 0) {
+      for (const stagedPlaneBus of debugStagedPlaneBuses) {
+        if (activeBoundaryReservationPlaneBuses.includes(stagedPlaneBus)) {
+          continue
+        }
+        const stagedViaPoints = matchComponentDogboneViaSites(
+          [
+            ...activeBoundaryReservationPlaneBuses,
+            stagedPlaneBus,
+            ...initiallyMatchedBoundaryBuses,
+          ],
+          {
+            viaDiameter: this.config.viaDiameter,
+            viaHoleDiameter: this.config.viaHoleDiameter,
+            traceWidth: this.config.traceWidth,
+            clearance: this.config.clearance,
+            maximumSearchStates: 100_000,
+            preferredBoundaryPerpendicularSideByBusId,
+            preferBoundaryOutwardByBusId,
+            fixedViaPointsByConnectionIndex: seedViaPoints,
+            additionalObstacles: denseAdditionalObstacles,
+            preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+            canShareCopper,
+          },
+        )
+        debugDense(
+          "plane-reservation:staged",
+          stagedPlaneBus.busId,
+          stagedViaPoints?.size ?? "failed",
+        )
+        if (!stagedViaPoints) break
+        seedViaPoints = new Map([...seedViaPoints, ...stagedViaPoints])
+        activeBoundaryReservationPlaneBuses.push(stagedPlaneBus)
+      }
+    }
+    debugDense("seed", seedViaPoints?.size ?? "failed")
+    if (seedViaPoints && process.env.FANOUT_DEBUG_DENSE_POINTS === "1") {
+      console.error(
+        "dense: seed-points",
+        [...seedViaPoints].map(([connectionIndex, point]) => ({
+          connection: connectionNameByIndex.get(connectionIndex),
+          point,
+        })),
+      )
+    }
+    let denseWorkUnitIndex = 1
+    const denseWorkUnitCount = boundaryBuses.length + planeBuses.length + 3
+    this.setInProgressPlans({
+      phase: "reserve-dense-via-sites",
+      plans: [],
+      strategy: "default",
+      unitIndex: denseWorkUnitIndex,
+      unitCount: denseWorkUnitCount,
+    })
+    yield
     if (seedViaPoints) {
       const denseBoundaryBusesInRoutingOrder = [
-        ...leadingWideSingletonBuses,
-        ...boundaryBuses.filter(
-          (bus) => !leadingWideSingletonBuses.includes(bus),
-        ),
+        ...multiLayerLeadingSingletonBuses,
+        ...boundaryBuses
+          .filter(
+            (bus) =>
+              !multiLayerLeadingSingletonBuses.includes(bus) &&
+              !throughAllLeadingBuses.includes(bus),
+          )
+          .flatMap((bus) => [
+            ...throughAllLeadingBuses.filter(
+              (candidate) => getContainingWideSourceField(candidate) === bus,
+            ),
+            bus,
+          ]),
       ]
       let fixedViaPointsByConnectionIndex: ReadonlyMap<
         number,
@@ -1321,7 +2066,24 @@ export class FanoutSolver extends BaseSolver {
           })
         })
       }
-      const routeMatchedBoundaryBus = (bus: PreparedBus): boolean => {
+      const routeMatchedBoundaryBusSteps = function* (
+        this: FanoutSolver,
+        bus: PreparedBus,
+      ): Generator<FanoutWorkYield, boolean, unknown> {
+        debugDense("route:start", bus.busId, matchedPlans.length)
+        if (process.env.FANOUT_DEBUG_DENSE_POINTS === "1") {
+          console.error(
+            "dense: points",
+            bus.busId,
+            bus.connections.map((connection) => ({
+              source: connection.sourcePoint,
+              via: fixedViaPointsByConnectionIndex.get(
+                connection.connectionIndex,
+              ),
+              target: connection.exitTargetPoint ?? connection.targetPoint,
+            })),
+          )
+        }
         const targetLayer = params.busLayerAssignments[bus.busId]
         if (!targetLayer) {
           return false
@@ -1342,10 +2104,60 @@ export class FanoutSolver extends BaseSolver {
           staticClearanceCache: this.routeStaticClearanceCache,
           fixedViaPointsByConnectionIndex,
           reservedVias: getReservedVias(bus),
-          viaMinimalOnly: true,
+          viaMinimalOnly: process.env.FANOUT_DEBUG_ALLOW_EXTRA_VIAS !== "1",
+          fixedViaFallbackRouteOrderAttempts: useConfiguredDensePlaneRouting
+            ? 6
+            : 24,
           cornerBandTargetTrackOffset: getCornerBandTargetTrackOffset(bus),
         } as const
-        let busPlans = routeBusAlternatives(routeParams, 1)[0]
+        const routeAlternatives = function* (
+          this: FanoutSolver,
+          candidateRouteParams: Parameters<typeof routeBusAlternativesSteps>[0],
+          maximumAlternatives: number,
+        ): Generator<FanoutWorkYield, FanoutRoutePlan[][], unknown> {
+          this.activeRoutingVisualization = null
+          const solver = this.createWorkSolver(
+            "BoundaryBusRoutingSolver",
+            this.routeBusAlternativesWorkSteps(
+              candidateRouteParams,
+              maximumAlternatives,
+            ),
+            undefined,
+            () => this.visualizeBoundaryRoutingState(),
+          )
+          return (yield { type: "subsolver", solver }) as FanoutRoutePlan[][]
+        }.bind(this)
+        const routableEscapeLayers =
+          bus.routableEscapeLayers ?? bus.allowedLayers ?? []
+        const singleLayerBus = routableEscapeLayers.some(
+          (layer) => layer !== targetLayer,
+        )
+          ? { ...bus, routableEscapeLayers: [targetLayer] }
+          : bus
+        const embeddedNarrowBusAlreadyRouted = boundaryBuses.some(
+          (candidate) =>
+            candidate.connections.length < 8 &&
+            getContainingWideSourceField(candidate) === bus &&
+            matchedPlans.some((plan) => plan.busId === candidate.busId),
+        )
+        // In the configured dense-plane mode, a second allowed layer is an
+        // optional winding crossover channel rather than a requirement. Try
+        // the simpler single-layer route first unless an already-routed narrow
+        // bus occupies that direct winding channel. Preserve the released
+        // multi-layer search order for callers that did not opt into this mode.
+        const preferSingleLayerWinding =
+          useConfiguredDensePlaneRouting &&
+          singleLayerBus !== bus &&
+          !embeddedNarrowBusAlreadyRouted
+        let busPlans = (yield* routeAlternatives(
+          preferSingleLayerWinding
+            ? { ...routeParams, bus: singleLayerBus }
+            : routeParams,
+          1,
+        ))[0]
+        if (!busPlans && preferSingleLayerWinding) {
+          busPlans = (yield* routeAlternatives(routeParams, 1))[0]
+        }
         if (busPlans && bus.maxLengthSkew !== undefined) {
           const lengths = busPlans.map((plan) => plan.length)
           const rawSkew = Math.max(...lengths) - Math.min(...lengths)
@@ -1360,7 +2172,7 @@ export class FanoutSolver extends BaseSolver {
           // skewed that compact meanders are unlikely to absorb the deficit.
           // This keeps already-near-matched buses on the single-attempt path.
           if (needsRouteDiversity) {
-            busPlans = routeBusAlternatives(routeParams, 3).toSorted(
+            busPlans = (yield* routeAlternatives(routeParams, 3)).toSorted(
               (first, second) => {
                 const firstLengths = first.map((plan) => plan.length)
                 const secondLengths = second.map((plan) => plan.length)
@@ -1374,16 +2186,43 @@ export class FanoutSolver extends BaseSolver {
           }
         }
         if (!busPlans) {
+          debugDense("route:failed", bus.busId)
           return false
         }
         matchedPlans.push(...busPlans)
+        debugDense("route:complete", bus.busId, busPlans.length)
         return true
-      }
+      }.bind(this)
 
       const firstBoundaryBus = denseBoundaryBusesInRoutingOrder[0]!
       const routedBoundaryBuses: PreparedBus[] = []
-      if (routeMatchedBoundaryBus(firstBoundaryBus)) {
+      const reserveAllPlaneDogbonesAfterFirstWideBus = (
+        bus: PreparedBus,
+      ): void => {
+        if (
+          bus.connections.length >= 8 &&
+          !useConfiguredDensePlaneRouting &&
+          process.env.FANOUT_DEBUG_NO_PLANE_EXPANSION !== "1" &&
+          activeBoundaryReservationPlaneBuses.length < planeBuses.length
+        ) {
+          activeBoundaryReservationPlaneBuses = planeBuses
+          debugDense("plane-reservations:expanded", planeBuses.length)
+        }
+      }
+      const firstBoundaryBusRouted =
+        yield* routeMatchedBoundaryBusSteps(firstBoundaryBus)
+      this.setInProgressPlans({
+        phase: "route-dense-boundary-buses",
+        plans: matchedPlans,
+        strategy: "default",
+        unitIndex: ++denseWorkUnitIndex,
+        unitCount: denseWorkUnitCount,
+        busId: firstBoundaryBus.busId,
+      })
+      yield
+      if (firstBoundaryBusRouted) {
         routedBoundaryBuses.push(firstBoundaryBus)
+        reserveAllPlaneDogbonesAfterFirstWideBus(firstBoundaryBus)
       } else {
         matchedRoutingSucceeded = false
       }
@@ -1402,18 +2241,51 @@ export class FanoutSolver extends BaseSolver {
           candidateIndex++
         ) {
           const candidateBus = remainingBoundaryBuses[candidateIndex]!
+          debugDense("candidate:start", candidateBus.busId)
+          const candidateMatchingBase = new Map(fixedViaPointsByConnectionIndex)
+          const debugLateFixedVias = process.env.FANOUT_DEBUG_LATE_FIXED_VIAS
+          if (debugLateFixedVias) {
+            const candidateConnectionIndices = new Set(
+              candidateBus.connections.map(
+                (connection) => connection.connectionIndex,
+              ),
+            )
+            for (const entry of debugLateFixedVias.split(",")) {
+              const parts = entry.split(":")
+              const rawY = parts.pop()
+              const rawX = parts.pop()
+              const connectionName = parts.join(":")
+              const connectionIndex = [...connectionNameByIndex].find(
+                ([, name]) => name === connectionName,
+              )?.[0]
+              const x = Number(rawX)
+              const y = Number(rawY)
+              if (
+                connectionIndex !== undefined &&
+                candidateConnectionIndices.has(connectionIndex) &&
+                Number.isFinite(x) &&
+                Number.isFinite(y)
+              ) {
+                candidateMatchingBase.set(connectionIndex, { x, y })
+              }
+            }
+          }
           const candidateHasFixedViaPoints = candidateBus.connections.every(
             (connection) =>
-              fixedViaPointsByConnectionIndex.has(connection.connectionIndex),
+              candidateMatchingBase.has(connection.connectionIndex),
           )
-          const extendedViaPoints =
+          const newlyMatchedViaPoints =
             jointViaPoints && candidateHasFixedViaPoints
               ? // The joint map is deliberately kept intact so getReservedVias()
                 // blocks every already-reserved future through-barrel during A*.
                 // Provisional singleton and plane dogbones are rematched later.
-                new Map(fixedViaPointsByConnectionIndex)
+                new Map(candidateMatchingBase)
               : matchComponentDogboneViaSites(
-                  [...planeBuses, ...routedBoundaryBuses, candidateBus],
+                  [
+                    ...activeBoundaryReservationPlaneBuses,
+                    ...routedBoundaryBuses,
+                    candidateBus,
+                  ],
                   {
                     viaDiameter: this.config.viaDiameter,
                     viaHoleDiameter: this.config.viaHoleDiameter,
@@ -1422,12 +2294,31 @@ export class FanoutSolver extends BaseSolver {
                     maximumSearchStates: 100_000,
                     preferredBoundaryPerpendicularSideByBusId,
                     preferBoundaryOutwardByBusId,
-                    fixedViaPointsByConnectionIndex:
-                      fixedViaPointsByConnectionIndex,
+                    fixedViaPointsByConnectionIndex: candidateMatchingBase,
                     blockingSegments,
+                    additionalObstacles: denseAdditionalObstacles,
+                    preferPlaneCheckerboardSites:
+                      useConfiguredDensePlaneRouting,
                     canShareCopper,
                   },
                 )
+          const extendedViaPoints = newlyMatchedViaPoints
+            ? new Map([...candidateMatchingBase, ...newlyMatchedViaPoints])
+            : null
+          debugDense(
+            "candidate:matched",
+            candidateBus.busId,
+            extendedViaPoints?.size ?? "failed",
+          )
+          this.setInProgressPlans({
+            phase: "reserve-next-dense-boundary-bus",
+            plans: matchedPlans,
+            strategy: "default",
+            unitIndex: denseWorkUnitIndex,
+            unitCount: denseWorkUnitCount,
+            busId: candidateBus.busId,
+          })
+          yield
           if (!extendedViaPoints) continue
           const previousFixedViaPoints = fixedViaPointsByConnectionIndex
           const previousPlanCount = matchedPlans.length
@@ -1441,7 +2332,12 @@ export class FanoutSolver extends BaseSolver {
           if (laterBuses.length === 1) {
             const laterBus = laterBuses[0]!
             const futureAssignment = matchComponentDogboneViaSites(
-              [...planeBuses, ...routedBoundaryBuses, candidateBus, laterBus],
+              [
+                ...activeBoundaryReservationPlaneBuses,
+                ...routedBoundaryBuses,
+                candidateBus,
+                laterBus,
+              ],
               {
                 viaDiameter: this.config.viaDiameter,
                 viaHoleDiameter: this.config.viaHoleDiameter,
@@ -1452,9 +2348,16 @@ export class FanoutSolver extends BaseSolver {
                 preferBoundaryOutwardByBusId,
                 fixedViaPointsByConnectionIndex: extendedViaPoints,
                 blockingSegments,
+                additionalObstacles: denseAdditionalObstacles,
+                preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
                 canShareCopper,
               },
             )
+            debugDense(
+              "future:matched",
+              laterBus.busId,
+              futureAssignment?.size ?? "failed",
+            )
             if (futureAssignment) {
               const candidateCountByConnectionIndex = new Map<number, number>()
               for (const candidate of getComponentDogboneViaSiteCandidates(
@@ -1465,6 +2368,8 @@ export class FanoutSolver extends BaseSolver {
                   traceWidth: this.config.traceWidth,
                   clearance: this.config.clearance,
                   blockingSegments,
+                  additionalObstacles: denseAdditionalObstacles,
+                  preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
                   canShareCopper,
                 },
               )) {
@@ -1499,7 +2404,8 @@ export class FanoutSolver extends BaseSolver {
             }
           }
           fixedViaPointsByConnectionIndex = candidateFixedViaPoints
-          if (routeMatchedBoundaryBus(candidateBus)) {
+          if (yield* routeMatchedBoundaryBusSteps(candidateBus)) {
+            debugDense("lookahead:start", candidateBus.busId)
             const candidateLeavesAFeasibleExtension =
               laterBuses.length === 0 ||
               laterBuses.some((laterBus) => {
@@ -1512,7 +2418,7 @@ export class FanoutSolver extends BaseSolver {
                 return Boolean(
                   matchComponentDogboneViaSites(
                     [
-                      ...planeBuses,
+                      ...activeBoundaryReservationPlaneBuses,
                       ...routedBoundaryBuses,
                       candidateBus,
                       laterBus,
@@ -1528,39 +2434,828 @@ export class FanoutSolver extends BaseSolver {
                       fixedViaPointsByConnectionIndex:
                         fixedViaPointsByConnectionIndex,
                       blockingSegments: lookaheadBlockingSegments,
+                      additionalObstacles: denseAdditionalObstacles,
+                      preferPlaneCheckerboardSites:
+                        useConfiguredDensePlaneRouting,
                       canShareCopper,
                     },
                   ),
                 )
-              })
-            if (candidateLeavesAFeasibleExtension) {
-              selectedBusIndex = candidateIndex
-              routedBoundaryBuses.push(candidateBus)
-              break
+              })
+            debugDense(
+              "lookahead:complete",
+              candidateBus.busId,
+              candidateLeavesAFeasibleExtension,
+            )
+            if (candidateLeavesAFeasibleExtension) {
+              selectedBusIndex = candidateIndex
+              routedBoundaryBuses.push(candidateBus)
+              reserveAllPlaneDogbonesAfterFirstWideBus(candidateBus)
+              this.setInProgressPlans({
+                phase: "route-dense-boundary-buses",
+                plans: matchedPlans,
+                strategy: "default",
+                unitIndex: ++denseWorkUnitIndex,
+                unitCount: denseWorkUnitCount,
+                busId: candidateBus.busId,
+              })
+              yield
+              break
+            }
+            matchedPlans.splice(previousPlanCount)
+          }
+          fixedViaPointsByConnectionIndex = previousFixedViaPoints
+          this.setInProgressPlans({
+            phase: "retry-dense-boundary-bus",
+            plans: matchedPlans,
+            strategy: "default",
+            unitIndex: denseWorkUnitIndex,
+            unitCount: denseWorkUnitCount,
+            busId: candidateBus.busId,
+          })
+          yield
+        }
+        if (selectedBusIndex < 0) {
+          matchedRoutingSucceeded = false
+          break
+        }
+        remainingBoundaryBuses.splice(selectedBusIndex, 1)
+      }
+      let matchedPlaneBusesInRoutingOrder: PreparedBus[] | null = null
+      if (matchedRoutingSucceeded) {
+        let feasibleViaPoints: Map<number, { x: number; y: number }> | null =
+          null
+        let feasibleAlternatePlanePlans: FanoutRoutePlan[] = []
+        const matchViaPointsAroundPlans = (
+          candidatePlans: readonly FanoutRoutePlan[],
+        ): Map<number, { x: number; y: number }> | null => {
+          feasibleAlternatePlanePlans = []
+          const fixedBoundaryViaPoints = new Map(
+            candidatePlans.flatMap((plan) =>
+              plan.via
+                ? [[plan.connectionIndex, plan.via.center] as const]
+                : [],
+            ),
+          )
+          const blockingSegments = candidatePlans.flatMap((plan) =>
+            plan.segments.map((segment) => ({
+              connectionIndex: plan.connectionIndex,
+              segment,
+            })),
+          )
+          if (
+            useConfiguredDensePlaneRouting ||
+            process.env.FANOUT_DEBUG_INCREMENTAL_PLANE_MATCH === "1"
+          ) {
+            let incrementalViaPoints = new Map(fixedBoundaryViaPoints)
+            const matchedPlaneBuses = [...activeBoundaryReservationPlaneBuses]
+            for (const planeBus of matchedPlaneBuses) {
+              for (const connection of planeBus.connections) {
+                const reservedPoint = fixedViaPointsByConnectionIndex.get(
+                  connection.connectionIndex,
+                )
+                if (reservedPoint) {
+                  incrementalViaPoints.set(
+                    connection.connectionIndex,
+                    reservedPoint,
+                  )
+                }
+              }
+            }
+            for (const planeBus of matchedPlaneBuses) {
+              const targetLayer = params.busLayerAssignments[planeBus.busId]
+              if (!targetLayer) return null
+              const reservedPlanePlans = routeBus({
+                srj: this.routingSrj,
+                bus: planeBus,
+                targetLayer,
+                acceptedPlans: [
+                  ...candidatePlans,
+                  ...feasibleAlternatePlanePlans,
+                ],
+                layerNames: this.config.layerNames,
+                traceWidth: this.config.traceWidth,
+                viaDiameter: this.config.viaDiameter,
+                viaHoleDiameter: this.config.viaHoleDiameter,
+                clearance: this.config.clearance,
+                compactBusTracks: this.config.compactBusTracks,
+                allowBlindAndBuriedVias: false,
+                allowSameNetMerges: this.config.allowSameNetMerges,
+                staticClearanceCache: this.routeStaticClearanceCache,
+                fixedViaPointsByConnectionIndex: incrementalViaPoints,
+              })
+              if (!reservedPlanePlans) return null
+              feasibleAlternatePlanePlans.push(...reservedPlanePlans)
+            }
+            const independentlyUnmatchablePlaneBuses = planeBuses.filter(
+              (planeBus) =>
+                !matchedPlaneBuses.includes(planeBus) &&
+                !matchComponentDogboneViaSites(
+                  [...matchedPlaneBuses, planeBus, ...boundaryBuses],
+                  {
+                    viaDiameter: this.config.viaDiameter,
+                    viaHoleDiameter: this.config.viaHoleDiameter,
+                    traceWidth: this.config.traceWidth,
+                    clearance: this.config.clearance,
+                    maximumSearchStates: 100_000,
+                    preferredBoundaryPerpendicularSideByBusId,
+                    preferBoundaryOutwardByBusId,
+                    fixedViaPointsByConnectionIndex: incrementalViaPoints,
+                    blockingSegments,
+                    additionalObstacles: denseAdditionalObstacles,
+                    preferPlaneCheckerboardSites:
+                      useConfiguredDensePlaneRouting,
+                    canShareCopper,
+                  },
+                ),
+            )
+            const shallowestPlaneLayerIndex = Math.min(
+              ...planeBuses.map((bus) =>
+                this.config.layerNames.indexOf(
+                  params.busLayerAssignments[bus.busId] ?? "",
+                ),
+              ),
+            )
+            const deeperPlaneBuses =
+              useConfiguredDensePlaneRouting ||
+              process.env.FANOUT_DEBUG_ROUTE_DEEP_PLANES_FIRST === "1"
+                ? planeBuses.filter(
+                    (bus) =>
+                      !matchedPlaneBuses.includes(bus) &&
+                      this.config.layerNames.indexOf(
+                        params.busLayerAssignments[bus.busId] ?? "",
+                      ) > shallowestPlaneLayerIndex,
+                  )
+                : []
+            const additionalAlternatePlaneBusIds = new Set([
+              ...this.config.denseUnrestrictedPlaneRoutingBusIds,
+              ...(process.env.FANOUT_DEBUG_ADDITIONAL_ALTERNATE_PLANE_BUS_IDS?.split(
+                ",",
+              ) ?? []),
+            ])
+            const additionalAlternatePlaneBuses = planeBuses.filter(
+              (bus) =>
+                !matchedPlaneBuses.includes(bus) &&
+                additionalAlternatePlaneBusIds.has(bus.busId),
+            )
+            const alternatePlaneBuses = [
+              ...deeperPlaneBuses,
+              ...independentlyUnmatchablePlaneBuses.filter(
+                (bus) => !deeperPlaneBuses.includes(bus),
+              ),
+              ...additionalAlternatePlaneBuses.filter(
+                (bus) =>
+                  !deeperPlaneBuses.includes(bus) &&
+                  !independentlyUnmatchablePlaneBuses.includes(bus),
+              ),
+            ]
+            const debugAlternatePlaneOrder =
+              process.env.FANOUT_DEBUG_ALTERNATE_PLANE_ORDER?.split(",") ?? []
+            const orderedAlternatePlaneBuses = alternatePlaneBuses.toSorted(
+              (first, second) => {
+                const firstLayerIndex = this.config.layerNames.indexOf(
+                  params.busLayerAssignments[first.busId] ?? "",
+                )
+                const secondLayerIndex = this.config.layerNames.indexOf(
+                  params.busLayerAssignments[second.busId] ?? "",
+                )
+                if (
+                  firstLayerIndex !== secondLayerIndex &&
+                  process.env.FANOUT_DEBUG_ALTERNATE_IGNORE_LAYERS !== "1"
+                ) {
+                  return process.env.FANOUT_DEBUG_ALTERNATE_SHALLOW_FIRST ===
+                    "1"
+                    ? firstLayerIndex - secondLayerIndex
+                    : secondLayerIndex - firstLayerIndex
+                }
+                const firstPriority = debugAlternatePlaneOrder.indexOf(
+                  first.busId,
+                )
+                const secondPriority = debugAlternatePlaneOrder.indexOf(
+                  second.busId,
+                )
+                return (
+                  (firstPriority < 0
+                    ? debugAlternatePlaneOrder.length
+                    : firstPriority) -
+                    (secondPriority < 0
+                      ? debugAlternatePlaneOrder.length
+                      : secondPriority) ||
+                  first.connections[0]!.connectionIndex -
+                    second.connections[0]!.connectionIndex
+                )
+              },
+            )
+            if (alternatePlaneBuses.length > 0) {
+              debugDense(
+                "plane-match:preflight-failed",
+                independentlyUnmatchablePlaneBuses.map((bus) => bus.busId),
+              )
+              if (
+                !useConfiguredDensePlaneRouting &&
+                process.env.FANOUT_DEBUG_ROUTE_UNMATCHED_PLANES !== "1"
+              ) {
+                return null
+              }
+              let alternatePlaneSearchStates = 0
+              const maximumAlternatePlaneSearchStates = Number(
+                process.env.FANOUT_DEBUG_ALTERNATE_SEARCH_STATES ??
+                  (useConfiguredDensePlaneRouting ? 3_000_000 : 1_000),
+              )
+              const maximumAlternatePlaneRoutes = Number(
+                process.env.FANOUT_DEBUG_ALTERNATE_ROUTE_COUNT ??
+                  (useConfiguredDensePlaneRouting ? 128 : 8),
+              )
+              let deepestAlternatePlaneSearchIndex = 0
+              const alternatePlaneFailureCountByBusId = new Map<
+                string,
+                number
+              >()
+              const getPlaneRouteAlternatives = (
+                planeBus: PreparedBus,
+                additionalAcceptedPlans: FanoutRoutePlan[],
+                maximumRoutes = maximumAlternatePlaneRoutes,
+              ): FanoutRoutePlan[][] => {
+                const targetLayer = params.busLayerAssignments[planeBus.busId]
+                if (!targetLayer) return []
+                return routeBusAlternatives(
+                  {
+                    srj: this.routingSrj,
+                    bus: planeBus,
+                    targetLayer,
+                    acceptedPlans: [
+                      ...candidatePlans,
+                      ...additionalAcceptedPlans,
+                    ],
+                    layerNames: this.config.layerNames,
+                    traceWidth: this.config.traceWidth,
+                    viaDiameter: this.config.viaDiameter,
+                    viaHoleDiameter: this.config.viaHoleDiameter,
+                    clearance: this.config.clearance,
+                    compactBusTracks: this.config.compactBusTracks,
+                    allowBlindAndBuriedVias: false,
+                    allowSameNetMerges: this.config.allowSameNetMerges,
+                    staticClearanceCache: this.routeStaticClearanceCache,
+                  },
+                  maximumRoutes,
+                )
+              }
+              const routeAlternatePlaneBuses = (
+                remainingPlaneBuses: PreparedBus[],
+                acceptedAlternatePlans: FanoutRoutePlan[],
+              ): FanoutRoutePlan[] | null => {
+                if (remainingPlaneBuses.length === 0) {
+                  return acceptedAlternatePlans
+                }
+                if (
+                  alternatePlaneSearchStates >=
+                  maximumAlternatePlaneSearchStates
+                ) {
+                  return null
+                }
+                deepestAlternatePlaneSearchIndex = Math.max(
+                  deepestAlternatePlaneSearchIndex,
+                  orderedAlternatePlaneBuses.length -
+                    remainingPlaneBuses.length,
+                )
+                const alternativesByBus = remainingPlaneBuses.map(
+                  (planeBus) => ({
+                    planeBus,
+                    alternatives: getPlaneRouteAlternatives(
+                      planeBus,
+                      acceptedAlternatePlans,
+                    ),
+                  }),
+                )
+                const orderedSelections =
+                  process.env.FANOUT_DEBUG_DYNAMIC_ALTERNATE_ORDER === "1"
+                    ? alternativesByBus.toSorted(
+                        (first, second) =>
+                          first.alternatives.length -
+                            second.alternatives.length ||
+                          orderedAlternatePlaneBuses.indexOf(first.planeBus) -
+                            orderedAlternatePlaneBuses.indexOf(second.planeBus),
+                      )
+                    : alternativesByBus
+                const selected = orderedSelections[0]!
+                const { planeBus, alternatives } = selected
+                if (
+                  process.env.FANOUT_DEBUG_ALTERNATE_CHOICES === "1" &&
+                  alternatePlaneSearchStates < 64
+                ) {
+                  debugDense(
+                    "plane-route:alternate-choice",
+                    `depth:${orderedAlternatePlaneBuses.length - remainingPlaneBuses.length}`,
+                    planeBus.busId,
+                    alternativesByBus.map((entry) => [
+                      entry.planeBus.busId,
+                      entry.alternatives.length,
+                    ]),
+                  )
+                }
+                if (alternatives.length === 0) {
+                  alternatePlaneFailureCountByBusId.set(
+                    planeBus.busId,
+                    (alternatePlaneFailureCountByBusId.get(planeBus.busId) ??
+                      0) + 1,
+                  )
+                  return null
+                }
+                const selectionsToSearch =
+                  process.env.FANOUT_DEBUG_BRANCH_ALTERNATE_ORDER === "1"
+                    ? orderedSelections
+                    : [selected]
+                const alternateActions = selectionsToSearch.flatMap(
+                  (selection) =>
+                    selection.alternatives.map((alternative) => ({
+                      selection,
+                      alternative,
+                      remaining: remainingPlaneBuses.filter(
+                        (candidate) => candidate !== selection.planeBus,
+                      ),
+                    })),
+                )
+                const orderedActions =
+                  process.env.FANOUT_DEBUG_LEAST_CONSTRAINING_ALTERNATES === "1"
+                    ? alternateActions
+                        .map((action) => {
+                          const acceptedPlans = [
+                            ...acceptedAlternatePlans,
+                            ...action.alternative,
+                          ]
+                          const remainingOptionCounts = action.remaining.map(
+                            (remainingBus) =>
+                              getPlaneRouteAlternatives(
+                                remainingBus,
+                                acceptedPlans,
+                                Math.min(4, maximumAlternatePlaneRoutes),
+                              ).length,
+                          )
+                          return {
+                            ...action,
+                            remainingOptionCounts,
+                            minimumRemainingOptions:
+                              remainingOptionCounts.length === 0
+                                ? Number.POSITIVE_INFINITY
+                                : Math.min(...remainingOptionCounts),
+                            totalRemainingOptions: remainingOptionCounts.reduce(
+                              (total, count) => total + count,
+                              0,
+                            ),
+                          }
+                        })
+                        .filter(
+                          (action) => action.minimumRemainingOptions !== 0,
+                        )
+                        .toSorted(
+                          (first, second) =>
+                            second.minimumRemainingOptions -
+                              first.minimumRemainingOptions ||
+                            second.totalRemainingOptions -
+                              first.totalRemainingOptions,
+                        )
+                    : alternateActions
+                for (const action of orderedActions) {
+                  alternatePlaneSearchStates++
+                  const completedPlans = routeAlternatePlaneBuses(
+                    action.remaining,
+                    [...acceptedAlternatePlans, ...action.alternative],
+                  )
+                  if (completedPlans) return completedPlans
+                  if (
+                    alternatePlaneSearchStates >=
+                    maximumAlternatePlaneSearchStates
+                  ) {
+                    break
+                  }
+                }
+                alternatePlaneFailureCountByBusId.set(
+                  planeBus.busId,
+                  (alternatePlaneFailureCountByBusId.get(planeBus.busId) ?? 0) +
+                    1,
+                )
+                return null
+              }
+              let alternatePlanePlans: FanoutRoutePlan[] | null
+              if (
+                useConfiguredDensePlaneRouting ||
+                process.env.FANOUT_DEBUG_EXACT_COVER_ALTERNATES === "1"
+              ) {
+                type IndependentPlaneRouteCandidate = {
+                  key: string
+                  planeBus: PreparedBus
+                  plans: FanoutRoutePlan[]
+                }
+                const candidateSets = orderedAlternatePlaneBuses.map(
+                  (planeBus) => ({
+                    planeBus,
+                    candidates: getPlaneRouteAlternatives(
+                      planeBus,
+                      feasibleAlternatePlanePlans,
+                    ).map((plans, index) => ({
+                      key: `${planeBus.busId}:${index}`,
+                      planeBus,
+                      plans,
+                    })),
+                  }),
+                )
+                debugDense(
+                  "plane-route:alternate-candidate-counts",
+                  candidateSets.map((candidateSet) => [
+                    candidateSet.planeBus.busId,
+                    candidateSet.candidates.length,
+                  ]),
+                )
+                const compatibilityByCandidatePair = new Map<string, boolean>()
+                const candidatesAreCompatible = (
+                  first: IndependentPlaneRouteCandidate,
+                  second: IndependentPlaneRouteCandidate,
+                ): boolean => {
+                  const cacheKey = [first.key, second.key].toSorted().join("|")
+                  const cached = compatibilityByCandidatePair.get(cacheKey)
+                  if (cached !== undefined) return cached
+                  const compatible = fanoutPlansAreMutuallyClear({
+                    plans: [...first.plans, ...second.plans],
+                    srj: this.routingSrj,
+                    clearance: this.config.clearance,
+                    allowSameNetMerges: this.config.allowSameNetMerges,
+                  })
+                  compatibilityByCandidatePair.set(cacheKey, compatible)
+                  return compatible
+                }
+                const selectCompatiblePlaneRoutes = (
+                  remainingCandidateSets: typeof candidateSets,
+                  selectedCandidates: IndependentPlaneRouteCandidate[],
+                ): IndependentPlaneRouteCandidate[] | null => {
+                  if (remainingCandidateSets.length === 0) {
+                    return selectedCandidates
+                  }
+                  if (
+                    alternatePlaneSearchStates >=
+                    maximumAlternatePlaneSearchStates
+                  ) {
+                    return null
+                  }
+                  deepestAlternatePlaneSearchIndex = Math.max(
+                    deepestAlternatePlaneSearchIndex,
+                    orderedAlternatePlaneBuses.length -
+                      remainingCandidateSets.length,
+                  )
+                  const selectedSet = remainingCandidateSets.toSorted(
+                    (first, second) =>
+                      first.candidates.length - second.candidates.length,
+                  )[0]!
+                  if (selectedSet.candidates.length === 0) {
+                    alternatePlaneFailureCountByBusId.set(
+                      selectedSet.planeBus.busId,
+                      (alternatePlaneFailureCountByBusId.get(
+                        selectedSet.planeBus.busId,
+                      ) ?? 0) + 1,
+                    )
+                    return null
+                  }
+                  const otherSets = remainingCandidateSets.filter(
+                    (candidateSet) => candidateSet !== selectedSet,
+                  )
+                  const candidateBatchSize = Number(
+                    process.env.FANOUT_DEBUG_ALTERNATE_CANDIDATE_BATCH_SIZE ??
+                      16,
+                  )
+                  for (
+                    let batchStart = 0;
+                    batchStart < selectedSet.candidates.length;
+                    batchStart += candidateBatchSize
+                  ) {
+                    const actions = selectedSet.candidates
+                      .slice(batchStart, batchStart + candidateBatchSize)
+                      .map((candidate) => {
+                        const projectedSets = otherSets.map((candidateSet) => ({
+                          ...candidateSet,
+                          candidates: candidateSet.candidates.filter(
+                            (otherCandidate) =>
+                              candidatesAreCompatible(
+                                candidate,
+                                otherCandidate,
+                              ),
+                          ),
+                        }))
+                        const projectedCounts = projectedSets.map(
+                          (candidateSet) => candidateSet.candidates.length,
+                        )
+                        return {
+                          candidate,
+                          projectedSets,
+                          minimumProjectedCount:
+                            projectedCounts.length === 0
+                              ? Number.POSITIVE_INFINITY
+                              : Math.min(...projectedCounts),
+                          totalProjectedCount: projectedCounts.reduce(
+                            (total, count) => total + count,
+                            0,
+                          ),
+                        }
+                      })
+                      .filter((action) => action.minimumProjectedCount !== 0)
+                      .toSorted(
+                        (first, second) =>
+                          second.minimumProjectedCount -
+                            first.minimumProjectedCount ||
+                          second.totalProjectedCount -
+                            first.totalProjectedCount,
+                      )
+                    for (const action of actions) {
+                      alternatePlaneSearchStates++
+                      const selected = selectCompatiblePlaneRoutes(
+                        action.projectedSets,
+                        [...selectedCandidates, action.candidate],
+                      )
+                      if (selected) return selected
+                      if (
+                        alternatePlaneSearchStates >=
+                        maximumAlternatePlaneSearchStates
+                      ) {
+                        break
+                      }
+                    }
+                    if (
+                      alternatePlaneSearchStates >=
+                      maximumAlternatePlaneSearchStates
+                    ) {
+                      break
+                    }
+                  }
+                  alternatePlaneFailureCountByBusId.set(
+                    selectedSet.planeBus.busId,
+                    (alternatePlaneFailureCountByBusId.get(
+                      selectedSet.planeBus.busId,
+                    ) ?? 0) + 1,
+                  )
+                  return null
+                }
+                const selectedCandidates = selectCompatiblePlaneRoutes(
+                  candidateSets,
+                  [],
+                )
+                alternatePlanePlans = selectedCandidates
+                  ? [
+                      ...feasibleAlternatePlanePlans,
+                      ...selectedCandidates.flatMap(
+                        (candidate) => candidate.plans,
+                      ),
+                    ]
+                  : null
+              } else {
+                alternatePlanePlans = routeAlternatePlaneBuses(
+                  orderedAlternatePlaneBuses,
+                  feasibleAlternatePlanePlans,
+                )
+              }
+              debugDense(
+                "plane-route:alternate-search",
+                alternatePlanePlans ? "complete" : "failed",
+                alternatePlaneSearchStates,
+                `depth:${deepestAlternatePlaneSearchIndex}/${orderedAlternatePlaneBuses.length}`,
+                [...alternatePlaneFailureCountByBusId].toSorted(
+                  ([, first], [, second]) => second - first,
+                ),
+              )
+              if (!alternatePlanePlans) return null
+              feasibleAlternatePlanePlans = alternatePlanePlans
+            }
+            let planeBusIdsRoutedWithoutDogbones = new Set<string>()
+            let allBlockingSegments = [...blockingSegments]
+            let alternateBlockingVias: {
+              connectionIndex: number
+              center: { x: number; y: number }
+              diameter: number
+              spanLayers: readonly string[]
+            }[] = []
+            let planeBusesToMatch = [...planeBuses]
+            let candidateCountByConnectionIndex = new Map<number, number>()
+            let candidatePointsByConnectionIndex = new Map<
+              number,
+              { x: number; y: number }[]
+            >()
+            const refreshPlaneDogboneCandidates = (): void => {
+              planeBusIdsRoutedWithoutDogbones = new Set(
+                feasibleAlternatePlanePlans.map((plan) => plan.busId),
+              )
+              const alternateBlockingSegments =
+                feasibleAlternatePlanePlans.flatMap((plan) =>
+                  [...plan.segments, ...(plan.planeEndpointSegments ?? [])].map(
+                    (segment) => ({
+                      connectionIndex: plan.connectionIndex,
+                      segment,
+                    }),
+                  ),
+                )
+              allBlockingSegments = [
+                ...blockingSegments,
+                ...alternateBlockingSegments,
+              ]
+              alternateBlockingVias = feasibleAlternatePlanePlans.flatMap(
+                (plan) =>
+                  [
+                    plan.via,
+                    ...(plan.additionalVias ?? []),
+                    plan.planeEndpointVia,
+                  ].flatMap((via) =>
+                    via
+                      ? [
+                          {
+                            connectionIndex: plan.connectionIndex,
+                            center: via.center,
+                            diameter: via.diameter,
+                            spanLayers: via.spanLayers,
+                          },
+                        ]
+                      : [],
+                  ),
+              )
+              planeBusesToMatch = planeBuses.filter(
+                (bus) => !planeBusIdsRoutedWithoutDogbones.has(bus.busId),
+              )
+              candidateCountByConnectionIndex = new Map()
+              candidatePointsByConnectionIndex = new Map()
+              for (const candidate of getComponentDogboneViaSiteCandidates(
+                planeBusesToMatch,
+                {
+                  viaDiameter: this.config.viaDiameter,
+                  viaHoleDiameter: this.config.viaHoleDiameter,
+                  traceWidth: this.config.traceWidth,
+                  clearance: this.config.clearance,
+                  blockingSegments: allBlockingSegments,
+                  blockingVias: alternateBlockingVias,
+                  additionalObstacles: denseAdditionalObstacles,
+                  preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+                  canShareCopper,
+                },
+              )) {
+                candidateCountByConnectionIndex.set(
+                  candidate.connectionIndex,
+                  (candidateCountByConnectionIndex.get(
+                    candidate.connectionIndex,
+                  ) ?? 0) + 1,
+                )
+                const points =
+                  candidatePointsByConnectionIndex.get(
+                    candidate.connectionIndex,
+                  ) ?? []
+                points.push(candidate.point)
+                candidatePointsByConnectionIndex.set(
+                  candidate.connectionIndex,
+                  points,
+                )
+              }
+            }
+            refreshPlaneDogboneCandidates()
+            for (
+              let promotionPass = 0;
+              promotionPass < planeBuses.length;
+              promotionPass++
+            ) {
+              const zeroCandidatePlaneBuses = planeBusesToMatch.filter(
+                (bus) =>
+                  !candidateCountByConnectionIndex.has(
+                    bus.connections[0]!.connectionIndex,
+                  ),
+              )
+              if (zeroCandidatePlaneBuses.length === 0) break
+              debugDense(
+                "plane-route:promote-zero-candidates",
+                zeroCandidatePlaneBuses.map((bus) => bus.busId),
+              )
+              if (
+                zeroCandidatePlaneBuses.some((bus) =>
+                  matchedPlaneBuses.includes(bus),
+                )
+              ) {
+                return null
+              }
+              for (const planeBus of zeroCandidatePlaneBuses) {
+                const targetLayer = params.busLayerAssignments[planeBus.busId]
+                if (!targetLayer) return null
+                const promotedPlans = routeBusAlternatives(
+                  {
+                    srj: this.routingSrj,
+                    bus: planeBus,
+                    targetLayer,
+                    acceptedPlans: [
+                      ...candidatePlans,
+                      ...feasibleAlternatePlanePlans,
+                    ],
+                    layerNames: this.config.layerNames,
+                    traceWidth: this.config.traceWidth,
+                    viaDiameter: this.config.viaDiameter,
+                    viaHoleDiameter: this.config.viaHoleDiameter,
+                    clearance: this.config.clearance,
+                    compactBusTracks: this.config.compactBusTracks,
+                    allowBlindAndBuriedVias: false,
+                    allowSameNetMerges: this.config.allowSameNetMerges,
+                    staticClearanceCache: this.routeStaticClearanceCache,
+                  },
+                  8,
+                )[0]
+                if (!promotedPlans) {
+                  debugDense("plane-route:promote-failed", planeBus.busId)
+                  return null
+                }
+                feasibleAlternatePlanePlans.push(...promotedPlans)
+              }
+              refreshPlaneDogboneCandidates()
+            }
+            const debugPlaneMatchOrder =
+              process.env.FANOUT_DEBUG_PLANE_MATCH_ORDER?.split(",") ?? []
+            const incrementalPlaneBuses = planeBusesToMatch.toSorted(
+              (first, second) => {
+                const candidateCountDifference =
+                  (candidateCountByConnectionIndex.get(
+                    first.connections[0]!.connectionIndex,
+                  ) ?? 0) -
+                  (candidateCountByConnectionIndex.get(
+                    second.connections[0]!.connectionIndex,
+                  ) ?? 0)
+                if (candidateCountDifference !== 0) {
+                  return candidateCountDifference
+                }
+                const firstPriority = debugPlaneMatchOrder.indexOf(first.busId)
+                const secondPriority = debugPlaneMatchOrder.indexOf(
+                  second.busId,
+                )
+                const priorityDifference =
+                  (firstPriority < 0
+                    ? debugPlaneMatchOrder.length
+                    : firstPriority) -
+                  (secondPriority < 0
+                    ? debugPlaneMatchOrder.length
+                    : secondPriority)
+                if (priorityDifference !== 0) return priorityDifference
+                return (
+                  first.connections[0]!.connectionIndex -
+                  second.connections[0]!.connectionIndex
+                )
+              },
+            )
+            for (const planeBus of incrementalPlaneBuses) {
+              if (matchedPlaneBuses.includes(planeBus)) continue
+              if (
+                process.env.FANOUT_DEBUG_PLANE_CANDIDATES?.split(",").includes(
+                  planeBus.busId,
+                )
+              ) {
+                debugDense(
+                  "plane-match:candidates",
+                  planeBus.busId,
+                  candidatePointsByConnectionIndex.get(
+                    planeBus.connections[0]!.connectionIndex,
+                  ),
+                )
+              }
+              const nextViaPoints = matchComponentDogboneViaSites(
+                [...matchedPlaneBuses, planeBus, ...boundaryBuses],
+                {
+                  viaDiameter: this.config.viaDiameter,
+                  viaHoleDiameter: this.config.viaHoleDiameter,
+                  traceWidth: this.config.traceWidth,
+                  clearance: this.config.clearance,
+                  maximumSearchStates: 100_000,
+                  preferredBoundaryPerpendicularSideByBusId,
+                  preferBoundaryOutwardByBusId,
+                  fixedViaPointsByConnectionIndex: incrementalViaPoints,
+                  blockingSegments: allBlockingSegments,
+                  blockingVias: alternateBlockingVias,
+                  additionalObstacles: denseAdditionalObstacles,
+                  preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+                  canShareCopper,
+                },
+              )
+              debugDense(
+                nextViaPoints
+                  ? "plane-match:incremental"
+                  : "plane-match:incremental-failed",
+                planeBus.busId,
+                candidateCountByConnectionIndex.get(
+                  planeBus.connections[0]!.connectionIndex,
+                ) ?? 0,
+                nextViaPoints?.get(planeBus.connections[0]!.connectionIndex),
+                nextViaPoints?.size ?? "failed",
+              )
+              if (!nextViaPoints) return null
+              incrementalViaPoints = new Map([
+                ...incrementalViaPoints,
+                ...nextViaPoints,
+              ])
+              matchedPlaneBuses.push(planeBus)
             }
-            matchedPlans.splice(previousPlanCount)
+            matchedPlaneBusesInRoutingOrder = matchedPlaneBuses.filter(
+              (bus) => !planeBusIdsRoutedWithoutDogbones.has(bus.busId),
+            )
+            debugDense(
+              "plane-match:incremental-complete",
+              incrementalViaPoints.size,
+            )
+            return incrementalViaPoints
           }
-          fixedViaPointsByConnectionIndex = previousFixedViaPoints
-        }
-        if (selectedBusIndex < 0) {
-          matchedRoutingSucceeded = false
-          break
-        }
-        remainingBoundaryBuses.splice(selectedBusIndex, 1)
-      }
-      if (matchedRoutingSucceeded) {
-        let feasibleViaPoints: Map<number, { x: number; y: number }> | null =
-          null
-        const matchViaPointsAroundPlans = (
-          candidatePlans: readonly FanoutRoutePlan[],
-        ): Map<number, { x: number; y: number }> | null => {
-          const fixedBoundaryViaPoints = new Map(
-            candidatePlans.flatMap((plan) =>
-              plan.via
-                ? [[plan.connectionIndex, plan.via.center] as const]
-                : [],
-            ),
-          )
           return matchComponentDogboneViaSites(
             [...planeBuses, ...boundaryBuses],
             {
@@ -1572,16 +3267,14 @@ export class FanoutSolver extends BaseSolver {
               preferredBoundaryPerpendicularSideByBusId,
               preferBoundaryOutwardByBusId,
               fixedViaPointsByConnectionIndex: fixedBoundaryViaPoints,
-              blockingSegments: candidatePlans.flatMap((plan) =>
-                plan.segments.map((segment) => ({
-                  connectionIndex: plan.connectionIndex,
-                  segment,
-                })),
-              ),
+              blockingSegments,
+              additionalObstacles: denseAdditionalObstacles,
+              preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
               canShareCopper,
             },
           )
         }
+        debugDense("length-match:start", matchedPlans.length)
         const matchedLengthResult = matchBusPlanLengths({
           plans: matchedPlans,
           preparedBuses: this.preparedBuses,
@@ -1598,22 +3291,45 @@ export class FanoutSolver extends BaseSolver {
             return true
           },
         })
+        debugDense(
+          "length-match:complete",
+          matchedLengthResult.plans?.length ?? "failed",
+        )
+        this.setInProgressPlans({
+          phase: "match-dense-boundary-lengths",
+          plans: matchedLengthResult.plans ?? matchedPlans,
+          strategy: "default",
+          unitIndex: ++denseWorkUnitIndex,
+          unitCount: denseWorkUnitCount,
+        })
+        yield
         if (matchedLengthResult.plans) {
           matchedPlans = matchedLengthResult.plans
           const rematchedViaPoints =
             feasibleViaPoints ?? matchViaPointsAroundPlans(matchedPlans)
           if (rematchedViaPoints) {
             fixedViaPointsByConnectionIndex = rematchedViaPoints
+            matchedPlans.push(...feasibleAlternatePlanePlans)
           } else {
             matchedRoutingSucceeded = false
           }
         } else {
           matchedRoutingSucceeded = false
         }
+        this.setInProgressPlans({
+          phase: "rematch-dense-via-sites",
+          plans: matchedPlans,
+          strategy: "default",
+          unitIndex: denseWorkUnitIndex,
+          unitCount: denseWorkUnitCount,
+        })
+        yield
       }
       if (matchedRoutingSucceeded) {
-        for (const bus of planeBuses) {
+        for (const bus of matchedPlaneBusesInRoutingOrder ?? planeBuses) {
+          debugDense("plane-route:start", bus.busId)
           const targetLayer = params.busLayerAssignments[bus.busId]
+          const blockingBusCounts = new Map<string, number>()
           const busPlans = targetLayer
             ? routeBus({
                 srj: this.routingSrj,
@@ -1629,17 +3345,36 @@ export class FanoutSolver extends BaseSolver {
                 allowBlindAndBuriedVias: false,
                 allowSameNetMerges: this.config.allowSameNetMerges,
                 staticClearanceCache: this.routeStaticClearanceCache,
+                blockingBusCounts,
                 fixedViaPointsByConnectionIndex,
               })
             : null
           if (!busPlans) {
+            debugDense(
+              "plane-route:failed",
+              bus.busId,
+              fixedViaPointsByConnectionIndex.get(
+                bus.connections[0]!.connectionIndex,
+              ),
+              [...blockingBusCounts],
+            )
             matchedRoutingSucceeded = false
             break
           }
           matchedPlans.push(...busPlans)
+          debugDense("plane-route:complete", bus.busId)
+          this.setInProgressPlans({
+            phase: "route-dense-plane-buses",
+            plans: matchedPlans,
+            strategy: "default",
+            unitIndex: ++denseWorkUnitIndex,
+            unitCount: denseWorkUnitCount,
+            busId: bus.busId,
+          })
+          yield
         }
       }
-      if (
+      const densePlansAreClear =
         matchedRoutingSucceeded &&
         fanoutPlansAreClear({
           plans: matchedPlans,
@@ -1649,11 +3384,19 @@ export class FanoutSolver extends BaseSolver {
           allowBlindAndBuriedVias: false,
           allowSameNetMerges: this.config.allowSameNetMerges,
         })
-      ) {
+      debugDense(
+        "dense-validation",
+        matchedRoutingSucceeded,
+        matchedPlans.length,
+        densePlansAreClear,
+      )
+      if (densePlansAreClear) {
         return { plans: matchedPlans, failedBusIds: [] }
       }
     }
 
+    if (process.env.FANOUT_DEBUG_DENSE_ONLY === "1") return null
+
     const maximumStates = 8
     const getBoundaryStates = (
       alternativesPerBoundaryBus: number,
@@ -2003,11 +3746,11 @@ export class FanoutSolver extends BaseSolver {
     return bestState
   }
 
-  private evaluateAssignmentWithStrategy(
+  private *evaluateAssignmentWithStrategySteps(
     assignmentIndex: number,
     busLayerAssignments: Readonly<Record<string, string>>,
     routingStrategy: RoutingStrategy,
-  ): EvaluatedAssignment {
+  ): Generator<FanoutWorkYield, EvaluatedAssignment, unknown> {
     let plans: AssignmentAttempt["plans"] = []
     let failedBusIds: string[] = []
     let blockingBusCounts = new Map<string, number>()
@@ -2026,21 +3769,53 @@ export class FanoutSolver extends BaseSolver {
         clearance: this.config.clearance,
         borderDistribution: this.config.borderDistribution,
       }
-      const singleLayerPlans =
-        routeSingleLayerWithPushAndShove(singleLayerParams) ??
-        (this.config.singleLayerAdaptiveExits
-          ? routeSingleLayerWithAdaptiveExits({
-              ...singleLayerParams,
-              availableBoundaryRegions: resolveAvailableBoundaryRegions(
-                this.options.availableCornersAndSides,
-              ),
-            })
-          : null)
+      let singleLayerPlans = routeSingleLayerWithPushAndShove(singleLayerParams)
+      if (!singleLayerPlans && this.config.singleLayerAdaptiveExits) {
+        this.setInProgressPlans({
+          phase: "prepare-single-layer-adaptive-exits",
+          plans,
+          strategy: routingStrategy,
+        })
+        yield
+        this.setInProgressPlans({
+          phase: "route-single-layer-adaptive-exits",
+          plans,
+          strategy: routingStrategy,
+        })
+        this.activeAdaptiveVisualization = null
+        const adaptiveSolver = this.createWorkSolver(
+          "SingleLayerAdaptiveExitSolver",
+          routeSingleLayerWithAdaptiveExitsSteps({
+            ...singleLayerParams,
+            availableBoundaryRegions: resolveAvailableBoundaryRegions(
+              this.options.availableCornersAndSides,
+            ),
+            onProgress: (visualization, adaptiveStats) => {
+              this.activeAdaptiveVisualization = visualization
+              this.stats = { ...this.stats, ...adaptiveStats }
+            },
+          }),
+          undefined,
+          () => this.visualizeAdaptiveRoutingState(),
+        )
+        singleLayerPlans = (yield {
+          type: "subsolver",
+          solver: adaptiveSolver,
+        }) as FanoutRoutePlan[] | null
+      }
       if (singleLayerPlans) {
         plans.push(...singleLayerPlans)
       } else {
         failedBusIds.push(...this.preparedBuses.map((bus) => bus.busId))
       }
+      this.setInProgressPlans({
+        phase: "route-single-layer",
+        plans,
+        strategy: routingStrategy,
+        unitIndex: 1,
+        unitCount: 1,
+      })
+      yield
     }
     const busesInRoutingOrder = [...this.preparedBuses].sort((a, b) => {
       const aUsesCoordinatedWinding = busUsesCoordinatedWinding(a)
@@ -2076,23 +3851,56 @@ export class FanoutSolver extends BaseSolver {
       )
     })
 
-    const mixedTerminationState =
-      !useSingleLayerPushAndShove && routingStrategy === "default"
-        ? this.routeDenseThroughAllMixedTerminations({
-            busLayerAssignments,
-            busesInRoutingOrder,
-          })
-        : null
+    let mixedTerminationState: MixedTerminationState | null = null
+    if (!useSingleLayerPushAndShove && routingStrategy === "default") {
+      const denseSolver = this.createWorkSolver(
+        "DenseMixedTerminationSolver",
+        this.routeDenseThroughAllMixedTerminationSteps({
+          busLayerAssignments,
+          busesInRoutingOrder,
+        }),
+        () => {
+          const workUnit = Number(this.stats.workUnit ?? 0)
+          const workUnitCount = Number(this.stats.workUnitCount ?? 0)
+          return workUnitCount > 0 ? workUnit / workUnitCount : 0
+        },
+      )
+      mixedTerminationState = (yield {
+        type: "subsolver",
+        solver: denseSolver,
+      }) as MixedTerminationState | null
+    }
+    if (
+      !mixedTerminationState &&
+      !useSingleLayerPushAndShove &&
+      routingStrategy === "default" &&
+      process.env.FANOUT_DEBUG_DENSE_ONLY === "1"
+    ) {
+      mixedTerminationState = {
+        plans: [],
+        failedBusIds: this.preparedBuses.map((bus) => bus.busId),
+      }
+    }
 
     if (mixedTerminationState) {
       plans = mixedTerminationState.plans
       failedBusIds = mixedTerminationState.failedBusIds
+      this.setInProgressPlans({
+        phase: "route-dense-mixed-terminations",
+        plans,
+        strategy: routingStrategy,
+        unitIndex: this.preparedBuses.length,
+        unitCount: this.preparedBuses.length,
+      })
+      yield
     }
 
     let routingPrefixKey = `${routingStrategy}|`
+    let routedBusIndex = 0
     for (const bus of useSingleLayerPushAndShove || mixedTerminationState
       ? []
       : busesInRoutingOrder) {
+      routedBusIndex++
       const targetLayer = busLayerAssignments[bus.busId]
       if (!targetLayer) {
         throw new Error(
@@ -2110,6 +3918,15 @@ export class FanoutSolver extends BaseSolver {
         plans = [...cachedPrefix.plans]
         failedBusIds = [...cachedPrefix.failedBusIds]
         blockingBusCounts = new Map(cachedPrefix.blockingBusCounts)
+        this.setInProgressPlans({
+          phase: "route-assignment",
+          plans,
+          strategy: routingStrategy,
+          unitIndex: routedBusIndex,
+          unitCount: busesInRoutingOrder.length,
+          busId: bus.busId,
+        })
+        yield
         continue
       }
       const currentBusBlockingCounts = new Map<string, number>()
@@ -2145,6 +3962,15 @@ export class FanoutSolver extends BaseSolver {
         failedBusIds: [...failedBusIds],
         blockingBusCounts: new Map(blockingBusCounts),
       })
+      this.setInProgressPlans({
+        phase: "route-assignment",
+        plans,
+        strategy: routingStrategy,
+        unitIndex: routedBusIndex,
+        unitCount: busesInRoutingOrder.length,
+        busId: bus.busId,
+      })
+      yield
     }
 
     let validationIssues: FanoutAttemptSummary["validationIssues"]
@@ -2218,6 +4044,11 @@ export class FanoutSolver extends BaseSolver {
       score,
       ...(validationIssues ? { validationIssues } : {}),
     }
+    this.setInProgressPlans({
+      phase: "finalize-assignment-strategy",
+      plans,
+      strategy: routingStrategy,
+    })
     return {
       summary,
       plans,
@@ -2228,15 +4059,16 @@ export class FanoutSolver extends BaseSolver {
     }
   }
 
-  private evaluateAssignment(
+  private *evaluateAssignmentSteps(
     assignmentIndex: number,
     busLayerAssignments: Readonly<Record<string, string>>,
-  ): EvaluatedAssignment {
-    let bestAttempt = this.evaluateAssignmentWithStrategy(
+  ): Generator<FanoutWorkYield, EvaluatedAssignment, unknown> {
+    let bestAttempt = yield* this.evaluateAssignmentWithStrategySteps(
       assignmentIndex,
       busLayerAssignments,
       "default",
     )
+    if (process.env.FANOUT_DEBUG_DENSE_ONLY === "1") return bestAttempt
     if (
       bestAttempt.summary.routedConnectionCount ===
         this.inputSrj.connections.length &&
@@ -2246,7 +4078,7 @@ export class FanoutSolver extends BaseSolver {
     }
 
     for (const routingStrategy of ["group-by-layer", "deep-first"] as const) {
-      const attempt = this.evaluateAssignmentWithStrategy(
+      const attempt = yield* this.evaluateAssignmentWithStrategySteps(
         assignmentIndex,
         busLayerAssignments,
         routingStrategy,
@@ -2274,10 +4106,10 @@ export class FanoutSolver extends BaseSolver {
    * power or signal lane cannot starve a later bus before the solver explores
    * an alternate layer/track combination.
    */
-  private evaluateGroupedBeam(
+  private *evaluateGroupedBeamSteps(
     assignmentIndex: number,
     groupByDirection = false,
-  ): EvaluatedAssignment | null {
+  ): Generator<FanoutWorkYield, EvaluatedAssignment | null, unknown> {
     if (this.config.escapeLayers.length < 2) return null
     if (this.preparedBuses.length > 56) return null
     const totalConnections = this.inputSrj.connections.length
@@ -2386,7 +4218,9 @@ export class FanoutSolver extends BaseSolver {
       )
     }
 
+    let searchedBusIndex = 0
     for (const bus of busesInSearchOrder) {
+      searchedBusIndex++
       const nextStates: GroupedBeamState[] = []
       for (const state of states) {
         const candidateLayers =
@@ -2474,6 +4308,15 @@ export class FanoutSolver extends BaseSolver {
         states.push(state)
         if (states.length >= beamWidth) break
       }
+      this.setInProgressPlans({
+        phase: "route-grouped-beam",
+        plans: states[0]?.plans ?? [],
+        strategy: "grouped-beam",
+        unitIndex: searchedBusIndex,
+        unitCount: busesInSearchOrder.length,
+        busId: bus.busId,
+      })
+      yield
     }
 
     let bestState: GroupedBeamState | undefined
@@ -2493,9 +4336,15 @@ export class FanoutSolver extends BaseSolver {
       (bus) => bus.maxLengthSkew !== undefined,
     )
     for (const state of states) {
-      if (state.plans.length !== this.inputSrj.connections.length) continue
+      if (state.plans.length !== this.inputSrj.connections.length) {
+        yield
+        continue
+      }
       const lengthMatching = this.matchCompletePlanLengths(state.plans)
-      if (!lengthMatching.plans) continue
+      if (!lengthMatching.plans) {
+        yield
+        continue
+      }
       const lengthMatchedPlans = lengthMatching.plans
       const candidateOutput = buildOutputSimpleRouteJson({
         inputSrj: this.inputSrj,
@@ -2505,6 +4354,7 @@ export class FanoutSolver extends BaseSolver {
       if (
         !this.validateCompletePlans(lengthMatchedPlans, candidateOutput).valid
       ) {
+        yield
         continue
       }
       const candidateState = { ...state, plans: lengthMatchedPlans }
@@ -2523,6 +4373,12 @@ export class FanoutSolver extends BaseSolver {
         bestAdditionalViaCount = candidateAdditionalViaCount
       }
       if (!hasLengthConstraints) break
+      this.setInProgressPlans({
+        phase: "validate-grouped-beam",
+        plans: lengthMatchedPlans,
+        strategy: "grouped-beam",
+      })
+      yield
     }
     if (!bestState || !outputSrj) return null
     const score = bestMatchedScore
@@ -2544,6 +4400,14 @@ export class FanoutSolver extends BaseSolver {
     }
   }
 
+  private *evaluateGroupedBeamAlternativesSteps(
+    assignmentIndex: number,
+  ): Generator<FanoutWorkYield, EvaluatedAssignment | null, unknown> {
+    const primaryAttempt = yield* this.evaluateGroupedBeamSteps(assignmentIndex)
+    if (primaryAttempt) return primaryAttempt
+    return yield* this.evaluateGroupedBeamSteps(assignmentIndex, true)
+  }
+
   private prioritizeFailedBusRepairs(
     assignment: Readonly<Record<string, string>>,
     failedBusIds: readonly string[],
@@ -2710,52 +4574,10 @@ export class FanoutSolver extends BaseSolver {
     return targetedRepairSearchFinished
   }
 
-  override _step(): void {
-    if (
-      this.nextAssignmentIndex > 0 &&
-      this.hasGloballyViaMinimalBestAttempt()
-    ) {
-      this.completeBestAttemptEndpoints()
-      this.solved = true
-      return
-    }
-    // Try the deterministic assignment and only its targeted repair queue
-    // before paying for the grouped beam. If the beam cannot solve, continue
-    // with the broader generated-assignment search below.
-    if (this.shouldEvaluateGroupedBeam()) {
-      this.groupedBeamEvaluated = true
-      let beamAttempt = this.evaluateGroupedBeam(-1)
-      if (!beamAttempt) {
-        beamAttempt = this.evaluateGroupedBeam(-1, true)
-      }
-      if (beamAttempt) {
-        this.attempts.push(beamAttempt.summary)
-        if (
-          !this.bestAttempt ||
-          this.isAttemptBetter(beamAttempt, this.bestAttempt)
-        ) {
-          this.bestAttempt = beamAttempt
-        }
-        const bestSummary = this.bestAttempt.summary
-        this.stats = {
-          assignment:
-            bestSummary.assignmentIndex < 0
-              ? 0
-              : bestSummary.assignmentIndex + 1,
-          assignmentCount: this.config.maxLayerCombinations,
-          routedBuses: `${bestSummary.routedBusCount}/${this.preparedBuses.length}`,
-          routedConnections: `${bestSummary.routedConnectionCount}/${this.inputSrj.connections.length}`,
-          failedBuses: "none",
-          bestScore: bestSummary.score,
-        }
-        if (
-          this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0
-        ) {
-          this.completeBestAttemptEndpoints()
-          this.solved = true
-          return
-        }
-      }
+  private commitGroupedBeamAttempt(
+    beamAttempt: EvaluatedAssignment | null,
+  ): void {
+    if (!beamAttempt) {
       if (
         this.hasCompleteBestAttempt() &&
         this.bestAttempt &&
@@ -2763,10 +4585,75 @@ export class FanoutSolver extends BaseSolver {
       ) {
         this.completeBestAttemptEndpoints()
         this.solved = true
-        return
       }
+      return
+    }
+    this.attempts.push(beamAttempt.summary)
+    if (
+      !this.bestAttempt ||
+      this.isAttemptBetter(beamAttempt, this.bestAttempt)
+    ) {
+      this.bestAttempt = beamAttempt
+    }
+    const bestSummary = this.bestAttempt.summary
+    this.stats = {
+      phase: "complete-grouped-beam",
+      assignment:
+        bestSummary.assignmentIndex < 0 ? 0 : bestSummary.assignmentIndex + 1,
+      assignmentCount: this.config.maxLayerCombinations,
+      routedBuses: `${bestSummary.routedBusCount}/${this.preparedBuses.length}`,
+      routedConnections: `${bestSummary.routedConnectionCount}/${this.inputSrj.connections.length}`,
+      failedBuses: "none",
+      bestScore: bestSummary.score,
+    }
+    if (this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0) {
+      this.completeBestAttemptEndpoints()
+      this.solved = true
+    }
+  }
+
+  private commitAssignmentAttempt(
+    assignment: Readonly<Record<string, string>>,
+    attempt: EvaluatedAssignment,
+  ): void {
+    this.nextAssignmentIndex++
+    this.evaluatedAssignmentKeys.add(JSON.stringify(assignment))
+    if (
+      !this.bestAttempt ||
+      attempt.summary.routedConnectionCount >=
+        this.bestAttempt.summary.routedConnectionCount
+    ) {
+      this.prioritizeFailedBusRepairs(
+        assignment,
+        attempt.summary.failedBusIds,
+        attempt.blockingBusIds,
+      )
+    }
+    this.attempts.push(attempt.summary)
+    if (!this.bestAttempt || this.isAttemptBetter(attempt, this.bestAttempt)) {
+      this.bestAttempt = attempt
+    }
+    this.stats = {
+      phase: "complete-assignment",
+      assignment: attempt.summary.assignmentIndex + 1,
+      assignmentCount: this.config.maxLayerCombinations,
+      routedBuses: `${attempt.summary.routedBusCount}/${this.preparedBuses.length}`,
+      routedConnections: `${attempt.summary.routedConnectionCount}/${this.inputSrj.connections.length}`,
+      failedBuses: attempt.summary.failedBusIds.join(", ") || "none",
+      bestScore: this.bestAttempt.summary.score,
+    }
+    if (
+      this.groupedBeamEvaluated &&
+      attempt.summary.routedConnectionCount ===
+        this.inputSrj.connections.length &&
+      this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0
+    ) {
+      this.completeBestAttemptEndpoints()
+      this.solved = true
     }
+  }
 
+  private getNextAssignment(): Readonly<Record<string, string>> | undefined {
     let assignment: Readonly<Record<string, string>> | undefined
     while (
       !assignment &&
@@ -2802,68 +4689,138 @@ export class FanoutSolver extends BaseSolver {
       if (this.evaluatedAssignmentKeys.has(candidateKey)) continue
       assignment = candidate
     }
-    if (!assignment && !this.groupedBeamEvaluated) return
-    if (!assignment) {
-      if (this.hasCompleteBestAttempt()) {
-        this.completeBestAttemptEndpoints()
-        this.solved = true
-      } else {
-        this.failed = true
-        const validationMessage =
-          this.lengthMatchingFailure?.message ??
-          this.bestAttempt?.summary.validationIssues?.[0]?.message
-        this.error = validationMessage
-          ? `FanoutSolver: ${validationMessage}`
-          : this.bestAttempt
-            ? `FanoutSolver: best layer assignment routed ${this.bestAttempt.summary.routedConnectionCount}/${this.inputSrj.connections.length} connections`
-            : "FanoutSolver: no layer assignment could be evaluated"
-      }
+    return assignment
+  }
+
+  private finishWithoutAnotherAssignment(): void {
+    if (this.hasCompleteBestAttempt()) {
+      this.completeBestAttemptEndpoints()
+      this.solved = true
       return
     }
+    this.failed = true
+    const validationMessage =
+      this.lengthMatchingFailure?.message ??
+      this.bestAttempt?.summary.validationIssues?.[0]?.message
+    this.error = validationMessage
+      ? `FanoutSolver: ${validationMessage}`
+      : this.bestAttempt
+        ? `FanoutSolver: best layer assignment routed ${this.bestAttempt.summary.routedConnectionCount}/${this.inputSrj.connections.length} connections`
+        : "FanoutSolver: no layer assignment could be evaluated"
+  }
 
-    const attempt = this.evaluateAssignment(
-      this.nextAssignmentIndex,
-      assignment,
-    )
-    this.nextAssignmentIndex++
-    this.evaluatedAssignmentKeys.add(JSON.stringify(assignment))
-    if (
-      !this.bestAttempt ||
-      attempt.summary.routedConnectionCount >=
-        this.bestAttempt.summary.routedConnectionCount
-    ) {
-      this.prioritizeFailedBusRepairs(
-        assignment,
-        attempt.summary.failedBusIds,
-        attempt.blockingBusIds,
-      )
-    }
-    this.attempts.push(attempt.summary)
-    if (!this.bestAttempt || this.isAttemptBetter(attempt, this.bestAttempt)) {
-      this.bestAttempt = attempt
+  override _step(): void {
+    if (this.activeOperation) {
+      this.stepActiveOperation()
+      return
     }
-    this.stats = {
-      assignment: attempt.summary.assignmentIndex + 1,
-      assignmentCount: this.config.maxLayerCombinations,
-      routedBuses: `${attempt.summary.routedBusCount}/${this.preparedBuses.length}`,
-      routedConnections: `${attempt.summary.routedConnectionCount}/${this.inputSrj.connections.length}`,
-      failedBuses: attempt.summary.failedBusIds.join(", ") || "none",
-      bestScore: this.bestAttempt.summary.score,
+
+    if (!this.routingInitialized) {
+      this.startOperation({
+        name: "FanoutCandidateLayerSolver",
+        generator: this.initializeRoutingSteps(),
+        onSolved: () => {},
+        getProgress: () =>
+          this.nextCandidateLayerBusIndex /
+          Math.max(1, this.boundaryBuses.length + 1),
+      })
+      return
     }
+
     if (
-      this.groupedBeamEvaluated &&
-      attempt.summary.routedConnectionCount ===
-        this.inputSrj.connections.length &&
-      this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0
+      this.nextAssignmentIndex > 0 &&
+      this.hasGloballyViaMinimalBestAttempt()
     ) {
       this.completeBestAttemptEndpoints()
       this.solved = true
+      return
+    }
+    // Try the deterministic assignment and only its targeted repair queue
+    // before paying for the grouped beam. If the beam cannot solve, continue
+    // with the broader generated-assignment search below.
+    if (this.shouldEvaluateGroupedBeam()) {
+      this.groupedBeamEvaluated = true
+      this.startOperation({
+        name: "FanoutGroupedBeamSolver",
+        generator: this.evaluateGroupedBeamAlternativesSteps(-1),
+        onSolved: (attempt) => this.commitGroupedBeamAttempt(attempt),
+        getProgress: () => {
+          const workUnit = Number(this.stats.workUnit ?? 0)
+          const workUnitCount = Number(this.stats.workUnitCount ?? 0)
+          return workUnitCount > 0 ? workUnit / workUnitCount : 0
+        },
+      })
+      this.stats = { ...this.stats, phase: "prepare-grouped-beam" }
+      return
+    }
+
+    const assignment = this.getNextAssignment()
+    if (!assignment && !this.groupedBeamEvaluated) return
+    if (!assignment) {
+      this.finishWithoutAnotherAssignment()
+      return
+    }
+
+    this.startOperation({
+      name: "FanoutAssignmentSolver",
+      generator: this.evaluateAssignmentSteps(
+        this.nextAssignmentIndex,
+        assignment,
+      ),
+      onSolved: (attempt) => this.commitAssignmentAttempt(assignment, attempt),
+      getProgress: () => {
+        const strategyIndex =
+          this.stats.routingStrategy === "group-by-layer"
+            ? 1
+            : this.stats.routingStrategy === "deep-first"
+              ? 2
+              : 0
+        const workUnit = Number(this.stats.workUnit ?? 0)
+        const workUnitCount = Number(this.stats.workUnitCount ?? 0)
+        const strategyFraction =
+          workUnitCount > 0 ? Math.min(1, workUnit / workUnitCount) : 0
+        return (strategyIndex + strategyFraction) / 3
+      },
+    })
+    this.stats = {
+      ...this.stats,
+      phase: "prepare-assignment",
+      assignment: this.nextAssignmentIndex + 1,
+      assignmentCount: this.config.maxLayerCombinations,
+      routedConnections: `0/${this.inputSrj.connections.length}`,
     }
   }
 
   computeProgress(): number {
     if (this.solved || this.failed) return 1
-    return this.nextAssignmentIndex / this.config.maxLayerCombinations
+    if (!this.routingInitialized) {
+      return (
+        0.05 *
+        (this.nextCandidateLayerBusIndex /
+          Math.max(1, this.boundaryBuses.length + 1))
+      )
+    }
+    let activeAssignmentFraction = 0
+    if (this.activeSubSolver?.getSolverName() === "FanoutAssignmentSolver") {
+      const strategyIndex =
+        this.stats.routingStrategy === "group-by-layer"
+          ? 1
+          : this.stats.routingStrategy === "deep-first"
+            ? 2
+            : 0
+      const workUnit = Number(this.stats.workUnit ?? 0)
+      const workUnitCount = Number(this.stats.workUnitCount ?? 0)
+      const strategyFraction =
+        workUnitCount > 0 ? Math.min(1, workUnit / workUnitCount) : 0
+      activeAssignmentFraction = (strategyIndex + strategyFraction) / 3
+    }
+    return Math.min(
+      0.99,
+      0.05 +
+        0.95 *
+          ((this.nextAssignmentIndex + activeAssignmentFraction) /
+            this.config.maxLayerCombinations),
+    )
   }
 
   override getConstructorParams(): [SimpleRouteJson, FanoutSolverOptions] {
@@ -2937,10 +4894,6 @@ export class FanoutSolver extends BaseSolver {
   }
 
   override visualize(): GraphicsObject {
-    const visualizedSrj =
-      this.endpointCompletion?.simpleRouteJson ??
-      this.bestAttempt?.outputSrj ??
-      this.inputSrj
-    return visualizeSimpleRouteJson(visualizedSrj)
+    return this.activeSubSolver?.visualize() ?? this.visualizeCurrentState()
   }
 }