@tscircuit/fanout-solver 0.0.38 → 0.0.40

package/lib/fanout-solver.ts

@@ -1,19 +1,30 @@
 import type { SimpleRouteJson } from "@tscircuit/capacity-autorouter"
 import { BaseSolver } from "@tscircuit/solver-utils"
 import type { GraphicsObject } from "graphics-debug"
-import { getCornerBandSide } from "./boundary-exit"
+import { addViaLayerMetadataToSrj } from "./add-via-layer-metadata"
+import { getCornerBandSide, getExitEdgeForDirection } from "./boundary-exit"
 import { buildOutputSimpleRouteJson } from "./build-output"
 import {
   type CompleteOriginalEndpointsResult,
   completeOriginalEndpoints,
 } from "./complete-original-endpoints"
-import { generateLayerAssignments, getCopperLayerNames } from "./layer-names"
+import {
+  generateLayerAssignments,
+  getCopperLayerNames,
+  getViaSpanLayers,
+} from "./layer-names"
 import { matchBusPlanLengths } from "./match-bus-lengths"
+import {
+  getComponentDogboneViaSiteCandidates,
+  matchComponentDogboneViaSites,
+} from "./match-component-dogbone-via-sites"
+import { connectionsShareElectricalNet } from "./net-identity"
 import {
   prepareFanoutBuses,
   resolveAvailableBoundaryRegions,
 } from "./prepare-buses"
 import {
+  fanoutPlansAreClear,
   type RouteBusStaticClearanceCache,
   routeBus,
   routeBusAlternatives,
@@ -30,6 +41,7 @@ import type {
   FanoutSolverOutput,
   FanoutValidationIssue,
   PreparedBus,
+  SimpleRouteJsonWithFanoutPlanes,
 } from "./types"
 import { validateFanoutSolution } from "./validate-fanout-solution"
 import { visualizeSimpleRouteJson } from "./visualize-simple-route-json"
@@ -40,6 +52,7 @@ interface ResolvedFanoutConfig {
   viaHoleDiameter: number
   clearance: number
   compactBusTracks: boolean
+  allowBlindAndBuriedVias: boolean
   allowSameNetMerges: boolean
   singleLayerPushAndShove: boolean
   singleLayerAdaptiveExits: boolean
@@ -59,6 +72,11 @@ interface GroupedBeamState {
   plans: FanoutRoutePlan[]
 }
 
+interface MixedTerminationState {
+  plans: FanoutRoutePlan[]
+  failedBusIds: string[]
+}
+
 type RoutingStrategy = "default" | "group-by-layer" | "deep-first"
 
 function resolvePositiveNumber(label: string, value: number): number {
@@ -131,6 +149,7 @@ function resolveConfig(
     viaHoleDiameter,
     clearance,
     compactBusTracks: options.compactBusTracks ?? false,
+    allowBlindAndBuriedVias: options.allowBlindAndBuriedVias ?? true,
     allowSameNetMerges: options.allowSameNetMerges ?? false,
     singleLayerPushAndShove: options.singleLayerPushAndShove ?? false,
     singleLayerAdaptiveExits: options.singleLayerAdaptiveExits ?? false,
@@ -216,6 +235,17 @@ function getLayerLoadPenaltyWeight(config: ResolvedFanoutConfig): number {
   return config.balanceLayerLoadByConnectionCount ? 0.25 : 0.01
 }
 
+function comparePlaneRoutingPriority(
+  first: PreparedBus,
+  second: PreparedBus,
+  allowBlindAndBuriedVias: boolean,
+): number {
+  const planeDifference =
+    Number(first.termination.type === "plane") -
+    Number(second.termination.type === "plane")
+  return allowBlindAndBuriedVias ? -planeDifference : planeDifference
+}
+
 function getPlanViaCount(plans: readonly FanoutRoutePlan[]): number {
   return plans.reduce(
     (count, plan) =>
@@ -439,6 +469,7 @@ function getCandidateEscapeLayersForBus(params: {
         viaHoleDiameter: config.viaHoleDiameter,
         clearance: config.clearance,
         compactBusTracks: config.compactBusTracks,
+        allowBlindAndBuriedVias: config.allowBlindAndBuriedVias,
         allowSameNetMerges: config.allowSameNetMerges,
         staticClearanceCache,
       }) !== null,
@@ -627,6 +658,7 @@ export class FanoutSolver extends BaseSolver {
       viaDiameter: this.config.viaDiameter,
       viaHoleDiameter: this.config.viaHoleDiameter,
       clearance: this.config.clearance,
+      allowBlindAndBuriedVias: this.config.allowBlindAndBuriedVias,
       effort: this.options.endpointCompletionEffort,
       routeDownstreamConnections: this.options.routeDownstreamConnections,
     })
@@ -658,6 +690,7 @@ export class FanoutSolver extends BaseSolver {
       preparedBuses: this.preparedBuses,
       sharedBoundary: this.getValidationBoundary(),
       clearance: this.config.clearance,
+      allowBlindAndBuriedVias: this.config.allowBlindAndBuriedVias,
     })
   }
 
@@ -670,10 +703,841 @@ export class FanoutSolver extends BaseSolver {
       inputSrj: this.inputSrj,
       sharedBoundary: this.getValidationBoundary(),
       clearance: this.config.clearance,
+      allowBlindAndBuriedVias: this.config.allowBlindAndBuriedVias,
       allowSameNetMerges: this.config.allowSameNetMerges,
     })
   }
 
+  /**
+   * Through-all source vias from a wide boundary bus can consume the only
+   * legal dogbone channel for nearby plane pads. Conversely, routing hundreds
+   * of singleton plane drops first can strand the boundary bus. Search a tiny
+   * number of whole-bus boundary alternatives, then fill the remaining plane
+   * 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: {
+    busLayerAssignments: Readonly<Record<string, string>>
+    busesInRoutingOrder: readonly PreparedBus[]
+  }): MixedTerminationState | null {
+    if (this.config.allowBlindAndBuriedVias) return null
+
+    const boundaryBuses = params.busesInRoutingOrder
+      .filter((bus) => bus.termination.type === "boundary")
+      .toSorted((first, second) => {
+        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 firstLayer = params.busLayerAssignments[first.busId]
+        const secondLayer = params.busLayerAssignments[second.busId]
+        const layerDifference =
+          this.config.layerNames.indexOf(firstLayer ?? "") -
+          this.config.layerNames.indexOf(secondLayer ?? "")
+        return -layerDifference
+      })
+    // 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
+    // dead-ends and needlessly triggers the widened boundary beam. The local
+    // rip-up/retry below handles the genuinely constrained drops.
+    const planeBuses = this.preparedBuses.filter(
+      (bus) => bus.termination.type === "plane",
+    )
+    if (
+      boundaryBuses.length === 0 ||
+      boundaryBuses.length > 4 ||
+      planeBuses.length < 8 ||
+      boundaryBuses.some((bus) => !busUsesCoordinatedWinding(bus)) ||
+      planeBuses.some((bus) => bus.connections.length !== 1) ||
+      boundaryBuses.length + planeBuses.length !==
+        params.busesInRoutingOrder.length
+    ) {
+      return null
+    }
+
+    const connectionNameByIndex = new Map(
+      this.preparedBuses.flatMap((bus) =>
+        bus.connections.map(
+          (connection) =>
+            [connection.connectionIndex, connection.connection.name] as const,
+        ),
+      ),
+    )
+    const preferredBoundaryPerpendicularSideByBusId = new Map(
+      boundaryBuses.map((bus) => [bus.busId, 1 as const]),
+    )
+    const preferBoundaryOutwardByBusId = new Map(
+      boundaryBuses.map((bus) => [
+        bus.busId,
+        getExitEdgeForDirection(bus.direction) !== bus.exitEdge,
+      ]),
+    )
+    const canShareCopper = (
+      firstConnectionIndex: number,
+      secondConnectionIndex: number,
+    ): boolean => {
+      if (!this.config.allowSameNetMerges) return false
+      const firstConnectionName =
+        connectionNameByIndex.get(firstConnectionIndex)
+      const secondConnectionName = connectionNameByIndex.get(
+        secondConnectionIndex,
+      )
+      return Boolean(
+        firstConnectionName &&
+          secondConnectionName &&
+          connectionsShareElectricalNet(
+            this.routingSrj,
+            firstConnectionName,
+            secondConnectionName,
+          ),
+      )
+    }
+    const seedViaPoints = 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,
+      },
+    )
+    if (seedViaPoints) {
+      let fixedViaPointsByConnectionIndex: ReadonlyMap<
+        number,
+        { x: number; y: number }
+      > = seedViaPoints
+      let matchedPlans: FanoutRoutePlan[] = []
+      let matchedRoutingSucceeded = true
+      const getReservedVias = (bus: PreparedBus) => {
+        const currentConnectionNames = new Set(
+          bus.connections.map((connection) => connection.connection.name),
+        )
+        return this.preparedBuses.flatMap((preparedBus) => {
+          const targetLayer = params.busLayerAssignments[preparedBus.busId]
+          if (!targetLayer) return []
+          return preparedBus.connections.flatMap((connection) => {
+            if (currentConnectionNames.has(connection.connection.name))
+              return []
+            const center = fixedViaPointsByConnectionIndex.get(
+              connection.connectionIndex,
+            )
+            if (!center) return []
+            return [
+              {
+                connectionName: connection.connection.name,
+                via: {
+                  center,
+                  diameter: this.config.viaDiameter,
+                  spanLayers: getViaSpanLayers({
+                    fromLayer: connection.sourceLayer,
+                    toLayer: targetLayer,
+                    layerNames: this.config.layerNames,
+                    allowBlindAndBuriedVias: false,
+                  }),
+                },
+              },
+            ]
+          })
+        })
+      }
+      const routeMatchedBoundaryBus = (bus: PreparedBus): boolean => {
+        const targetLayer = params.busLayerAssignments[bus.busId]
+        if (!targetLayer) {
+          return false
+        }
+        const routeParams = {
+          srj: this.routingSrj,
+          bus,
+          targetLayer,
+          acceptedPlans: matchedPlans,
+          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,
+          reservedVias: getReservedVias(bus),
+          viaMinimalOnly: true,
+        } as const
+        let busPlans = routeBusAlternatives(routeParams, 1)[0]
+        if (busPlans && bus.maxLengthSkew !== undefined) {
+          const lengths = busPlans.map((plan) => plan.length)
+          const rawSkew = Math.max(...lengths) - Math.min(...lengths)
+          const needsRouteDiversity =
+            rawSkew - bus.maxLengthSkew > Math.max(1, bus.maxLengthSkew * 0.25)
+          // Only pay for additional A* variants when the first topology is so
+          // 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(
+              (first, second) => {
+                const firstLengths = first.map((plan) => plan.length)
+                const secondLengths = second.map((plan) => plan.length)
+                return (
+                  Math.max(...firstLengths) -
+                  Math.min(...firstLengths) -
+                  (Math.max(...secondLengths) - Math.min(...secondLengths))
+                )
+              },
+            )[0]
+          }
+        }
+        if (!busPlans) {
+          return false
+        }
+        matchedPlans.push(...busPlans)
+        return true
+      }
+
+      const firstBoundaryBus = boundaryBuses[0]!
+      const routedBoundaryBuses: PreparedBus[] = []
+      if (routeMatchedBoundaryBus(firstBoundaryBus)) {
+        routedBoundaryBuses.push(firstBoundaryBus)
+      } else {
+        matchedRoutingSucceeded = false
+      }
+      const remainingBoundaryBuses = boundaryBuses.slice(1)
+      while (matchedRoutingSucceeded && remainingBoundaryBuses.length > 0) {
+        const blockingSegments = matchedPlans.flatMap((plan) =>
+          plan.segments.map((segment) => ({
+            connectionIndex: plan.connectionIndex,
+            segment,
+          })),
+        )
+        let selectedBusIndex = -1
+        for (
+          let candidateIndex = 0;
+          candidateIndex < remainingBoundaryBuses.length;
+          candidateIndex++
+        ) {
+          const candidateBus = remainingBoundaryBuses[candidateIndex]!
+          const extendedViaPoints = matchComponentDogboneViaSites(
+            [...planeBuses, ...routedBoundaryBuses, candidateBus],
+            {
+              viaDiameter: this.config.viaDiameter,
+              viaHoleDiameter: this.config.viaHoleDiameter,
+              traceWidth: this.config.traceWidth,
+              clearance: this.config.clearance,
+              maximumSearchStates: 100_000,
+              preferredBoundaryPerpendicularSideByBusId,
+              preferBoundaryOutwardByBusId,
+              fixedViaPointsByConnectionIndex: fixedViaPointsByConnectionIndex,
+              blockingSegments,
+              canShareCopper,
+            },
+          )
+          if (!extendedViaPoints) continue
+          const previousFixedViaPoints = fixedViaPointsByConnectionIndex
+          const previousPlanCount = matchedPlans.length
+          const laterBuses = remainingBoundaryBuses.filter(
+            (_, laterIndex) => laterIndex !== candidateIndex,
+          )
+          let candidateFixedViaPoints: ReadonlyMap<
+            number,
+            { x: number; y: number }
+          > = extendedViaPoints
+          if (laterBuses.length === 1) {
+            const laterBus = laterBuses[0]!
+            const futureAssignment = matchComponentDogboneViaSites(
+              [...planeBuses, ...routedBoundaryBuses, candidateBus, laterBus],
+              {
+                viaDiameter: this.config.viaDiameter,
+                viaHoleDiameter: this.config.viaHoleDiameter,
+                traceWidth: this.config.traceWidth,
+                clearance: this.config.clearance,
+                maximumSearchStates: 100_000,
+                preferredBoundaryPerpendicularSideByBusId,
+                preferBoundaryOutwardByBusId,
+                fixedViaPointsByConnectionIndex: extendedViaPoints,
+                blockingSegments,
+                canShareCopper,
+              },
+            )
+            if (futureAssignment) {
+              const candidateCountByConnectionIndex = new Map<number, number>()
+              for (const candidate of getComponentDogboneViaSiteCandidates(
+                [laterBus],
+                {
+                  viaDiameter: this.config.viaDiameter,
+                  viaHoleDiameter: this.config.viaHoleDiameter,
+                  traceWidth: this.config.traceWidth,
+                  clearance: this.config.clearance,
+                  blockingSegments,
+                  canShareCopper,
+                },
+              )) {
+                candidateCountByConnectionIndex.set(
+                  candidate.connectionIndex,
+                  (candidateCountByConnectionIndex.get(
+                    candidate.connectionIndex,
+                  ) ?? 0) + 1,
+                )
+              }
+              const constrainedConnections = laterBus.connections.toSorted(
+                (first, second) =>
+                  (candidateCountByConnectionIndex.get(first.connectionIndex) ??
+                    0) -
+                    (candidateCountByConnectionIndex.get(
+                      second.connectionIndex,
+                    ) ?? 0) || first.connectionIndex - second.connectionIndex,
+              )
+              const repairedViaPoints = new Map(extendedViaPoints)
+              for (const connection of constrainedConnections) {
+                const criticalPoint = futureAssignment.get(
+                  connection.connectionIndex,
+                )
+                if (criticalPoint) {
+                  repairedViaPoints.set(
+                    connection.connectionIndex,
+                    criticalPoint,
+                  )
+                }
+              }
+              candidateFixedViaPoints = repairedViaPoints
+            }
+          }
+          fixedViaPointsByConnectionIndex = candidateFixedViaPoints
+          if (routeMatchedBoundaryBus(candidateBus)) {
+            const candidateLeavesAFeasibleExtension =
+              laterBuses.length === 0 ||
+              laterBuses.some((laterBus) => {
+                const lookaheadBlockingSegments = matchedPlans.flatMap((plan) =>
+                  plan.segments.map((segment) => ({
+                    connectionIndex: plan.connectionIndex,
+                    segment,
+                  })),
+                )
+                return Boolean(
+                  matchComponentDogboneViaSites(
+                    [
+                      ...planeBuses,
+                      ...routedBoundaryBuses,
+                      candidateBus,
+                      laterBus,
+                    ],
+                    {
+                      viaDiameter: this.config.viaDiameter,
+                      viaHoleDiameter: this.config.viaHoleDiameter,
+                      traceWidth: this.config.traceWidth,
+                      clearance: this.config.clearance,
+                      maximumSearchStates: 100_000,
+                      preferredBoundaryPerpendicularSideByBusId,
+                      preferBoundaryOutwardByBusId,
+                      fixedViaPointsByConnectionIndex:
+                        fixedViaPointsByConnectionIndex,
+                      blockingSegments: lookaheadBlockingSegments,
+                      canShareCopper,
+                    },
+                  ),
+                )
+              })
+            if (candidateLeavesAFeasibleExtension) {
+              selectedBusIndex = candidateIndex
+              routedBoundaryBuses.push(candidateBus)
+              break
+            }
+            matchedPlans.splice(previousPlanCount)
+          }
+          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],
+            {
+              viaDiameter: this.config.viaDiameter,
+              viaHoleDiameter: this.config.viaHoleDiameter,
+              traceWidth: this.config.traceWidth,
+              clearance: this.config.clearance,
+              maximumSearchStates: 100_000,
+              preferredBoundaryPerpendicularSideByBusId,
+              preferBoundaryOutwardByBusId,
+              fixedViaPointsByConnectionIndex: fixedBoundaryViaPoints,
+              blockingSegments: candidatePlans.flatMap((plan) =>
+                plan.segments.map((segment) => ({
+                  connectionIndex: plan.connectionIndex,
+                  segment,
+                })),
+              ),
+              canShareCopper,
+            },
+          )
+        }
+        const matchedLengthResult = matchBusPlanLengths({
+          plans: matchedPlans,
+          preparedBuses: this.preparedBuses,
+          inputSrj: this.inputSrj,
+          sharedBoundary: this.getValidationBoundary(),
+          clearance: this.config.clearance,
+          allowBlindAndBuriedVias: false,
+          allowSameNetMerges: this.config.allowSameNetMerges,
+          allowMatchingInsideDenseBounds: true,
+          candidatePlansAreFeasible: (candidatePlans) => {
+            const candidateViaPoints = matchViaPointsAroundPlans(candidatePlans)
+            if (!candidateViaPoints) return false
+            feasibleViaPoints = candidateViaPoints
+            return true
+          },
+        })
+        if (matchedLengthResult.plans) {
+          matchedPlans = matchedLengthResult.plans
+          const rematchedViaPoints =
+            feasibleViaPoints ?? matchViaPointsAroundPlans(matchedPlans)
+          if (rematchedViaPoints) {
+            fixedViaPointsByConnectionIndex = rematchedViaPoints
+          } else {
+            matchedRoutingSucceeded = false
+          }
+        } else {
+          matchedRoutingSucceeded = false
+        }
+      }
+      if (matchedRoutingSucceeded) {
+        for (const bus of planeBuses) {
+          const targetLayer = params.busLayerAssignments[bus.busId]
+          const busPlans = targetLayer
+            ? routeBus({
+                srj: this.routingSrj,
+                bus,
+                targetLayer,
+                acceptedPlans: matchedPlans,
+                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,
+              })
+            : null
+          if (!busPlans) {
+            matchedRoutingSucceeded = false
+            break
+          }
+          matchedPlans.push(...busPlans)
+        }
+      }
+      if (
+        matchedRoutingSucceeded &&
+        fanoutPlansAreClear({
+          plans: matchedPlans,
+          srj: this.routingSrj,
+          sharedBoundary: boundaryBuses[0]!.sharedBoundary,
+          clearance: this.config.clearance,
+          allowBlindAndBuriedVias: false,
+          allowSameNetMerges: this.config.allowSameNetMerges,
+        })
+      ) {
+        return { plans: matchedPlans, failedBusIds: [] }
+      }
+    }
+
+    const maximumStates = 8
+    const getBoundaryStates = (
+      alternativesPerBoundaryBus: number,
+      initialPlans: readonly FanoutRoutePlan[] = [],
+    ): MixedTerminationState[] | null => {
+      let states: MixedTerminationState[] = [
+        { plans: [...initialPlans], failedBusIds: [] },
+      ]
+      for (const bus of boundaryBuses) {
+        const targetLayer = params.busLayerAssignments[bus.busId]
+        if (!targetLayer) return null
+        const nextStates: MixedTerminationState[] = []
+        const alternativesByState = states.map((state) => ({
+          state,
+          alternatives: routeBusAlternatives(
+            {
+              srj: this.routingSrj,
+              bus,
+              targetLayer,
+              acceptedPlans: state.plans,
+              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,
+            },
+            alternativesPerBoundaryBus,
+          ),
+        }))
+        for (
+          let alternativeIndex = 0;
+          alternativeIndex < alternativesPerBoundaryBus;
+          alternativeIndex++
+        ) {
+          for (const { state, alternatives } of alternativesByState) {
+            const alternative = alternatives[alternativeIndex]
+            if (!alternative) continue
+            nextStates.push({
+              plans: [...state.plans, ...alternative],
+              failedBusIds: [],
+            })
+            if (nextStates.length >= maximumStates) break
+          }
+          if (nextStates.length >= maximumStates) break
+        }
+        if (nextStates.length === 0) return null
+        states = nextStates
+      }
+      return states
+    }
+
+    const getJointReservedBoundaryState = (
+      initialPlans: readonly FanoutRoutePlan[],
+    ): MixedTerminationState | null => {
+      if (boundaryBuses.length !== 2) return null
+      const [firstBus, secondBus] = boundaryBuses
+      if (!firstBus || !secondBus) return null
+      const routeBoundaryBus = (
+        bus: PreparedBus,
+        acceptedPlans: FanoutRoutePlan[],
+        rejectedViaMinimalCandidates?: FanoutRoutePlan[][],
+      ): FanoutRoutePlan[] | null => {
+        const targetLayer = params.busLayerAssignments[bus.busId]
+        if (!targetLayer) return null
+        return (
+          routeBusAlternatives(
+            {
+              srj: this.routingSrj,
+              bus,
+              targetLayer,
+              acceptedPlans,
+              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,
+              rejectedViaMinimalCandidates,
+              stopAfterFirstRejectedViaMinimalCandidate:
+                rejectedViaMinimalCandidates !== undefined,
+            },
+            1,
+          )[0] ?? null
+        )
+      }
+
+      const firstPlans = routeBoundaryBus(firstBus, [...initialPlans])
+      if (!firstPlans) return null
+      const rejectedSecondCandidates: FanoutRoutePlan[][] = []
+      const secondPlans = routeBoundaryBus(
+        secondBus,
+        [...initialPlans, ...firstPlans],
+        rejectedSecondCandidates,
+      )
+      if (secondPlans) {
+        return {
+          plans: [...initialPlans, ...firstPlans, ...secondPlans],
+          failedBusIds: [],
+        }
+      }
+
+      const rejectedSecondPlans = rejectedSecondCandidates[0]
+      if (!rejectedSecondPlans) return null
+      // Keep the candidate's exact copper/vias as immutable blockers while
+      // rerouting the earlier bus, but exclude it from corner-slot allocation.
+      const reservedSecondPlans = rejectedSecondPlans.map((plan) => ({
+        ...plan,
+        termination: {
+          type: "plane" as const,
+          layer: plan.targetLayer,
+        },
+      }))
+      const reroutedFirstPlans = routeBoundaryBus(firstBus, [
+        ...initialPlans,
+        ...reservedSecondPlans,
+      ])
+      if (!reroutedFirstPlans) return null
+      const combinedPlans = [
+        ...initialPlans,
+        ...reroutedFirstPlans,
+        ...rejectedSecondPlans,
+      ]
+      if (
+        !fanoutPlansAreClear({
+          plans: combinedPlans,
+          srj: this.routingSrj,
+          sharedBoundary: firstBus.sharedBoundary,
+          clearance: this.config.clearance,
+          allowBlindAndBuriedVias: false,
+          allowSameNetMerges: this.config.allowSameNetMerges,
+        })
+      ) {
+        return null
+      }
+      return { plans: combinedPlans, failedBusIds: [] }
+    }
+
+    const planeBusById = new Map(planeBuses.map((bus) => [bus.busId, bus]))
+    const routePlaneBus = (
+      bus: PreparedBus,
+      acceptedPlans: FanoutRoutePlan[],
+      blockingBusCounts?: Map<string, number>,
+    ): FanoutRoutePlan[] | null => {
+      const targetLayer = params.busLayerAssignments[bus.busId]
+      if (!targetLayer) return null
+      return routeBus({
+        srj: this.routingSrj,
+        bus,
+        targetLayer,
+        acceptedPlans,
+        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,
+        blockingBusCounts,
+      })
+    }
+
+    const routePlaneOrder = (
+      boundaryPlans: readonly FanoutRoutePlan[],
+      planeOrder: readonly PreparedBus[],
+    ): MixedTerminationState => {
+      const state: MixedTerminationState = {
+        plans: [...boundaryPlans],
+        failedBusIds: [],
+      }
+      for (const bus of planeOrder) {
+        const blockingBusCounts = new Map<string, number>()
+        let busPlans = routePlaneBus(bus, state.plans, blockingBusCounts)
+
+        // A plane dogbone can lose its only local channel to one or two
+        // earlier singleton drops. Rip up only the strongest local blockers,
+        // route the constrained drop first, then put the displaced drops back.
+        // Boundary buses are immutable here and the search is capped at 36
+        // blocker pairs, so dense fields remain predictable.
+        if (!busPlans) {
+          const blockerIds = [...blockingBusCounts.entries()]
+            .filter(([busId]) =>
+              state.plans.some((plan) => plan.busId === busId),
+            )
+            .filter(([busId]) => planeBusById.has(busId))
+            .toSorted(
+              ([, firstCount], [, secondCount]) => secondCount - firstCount,
+            )
+            .slice(0, 8)
+            .map(([busId]) => busId)
+          const ripupSets = [
+            ...blockerIds.map((busId) => [busId]),
+            ...blockerIds.flatMap((first, firstIndex) =>
+              blockerIds.slice(firstIndex + 1).map((second) => [first, second]),
+            ),
+          ]
+          for (const ripupIds of ripupSets) {
+            const ripupIdSet = new Set(ripupIds)
+            const candidatePlans = state.plans.filter(
+              (plan) => !ripupIdSet.has(plan.busId),
+            )
+            const constrainedPlans = routePlaneBus(bus, candidatePlans)
+            if (!constrainedPlans) continue
+            candidatePlans.push(...constrainedPlans)
+            let repairSucceeded = true
+            for (const blockerId of ripupIds) {
+              const blockerBus = planeBusById.get(blockerId)
+              const replacementPlans = blockerBus
+                ? routePlaneBus(blockerBus, candidatePlans)
+                : null
+              if (!replacementPlans) {
+                repairSucceeded = false
+                break
+              }
+              candidatePlans.push(...replacementPlans)
+            }
+            if (!repairSucceeded) continue
+            state.plans = candidatePlans
+            busPlans = []
+            break
+          }
+        }
+
+        if (busPlans) state.plans.push(...busPlans)
+        else state.failedBusIds.push(bus.busId)
+      }
+      return state
+    }
+
+    let bestState: MixedTerminationState | null = null
+    let mostRecentBoundaryBestState: MixedTerminationState | null = null
+    const evaluateBoundaryStates = (
+      states: readonly MixedTerminationState[],
+      initialPlaneOrder: readonly PreparedBus[],
+    ): MixedTerminationState | null => {
+      let localBestState: MixedTerminationState | null = null
+      for (const boundaryState of states) {
+        let planeOrder = [...initialPlaneOrder]
+        const seenPlaneOrders = new Set<string>()
+        for (let retryIndex = 0; retryIndex < 3; retryIndex++) {
+          const orderKey = planeOrder.map((bus) => bus.busId).join("\u0000")
+          if (seenPlaneOrders.has(orderKey)) break
+          seenPlaneOrders.add(orderKey)
+          const state = routePlaneOrder(boundaryState.plans, planeOrder)
+          if (
+            !bestState ||
+            state.plans.length > bestState.plans.length ||
+            (state.plans.length === bestState.plans.length &&
+              state.failedBusIds.length < bestState.failedBusIds.length)
+          ) {
+            bestState = state
+          }
+          if (
+            !localBestState ||
+            state.plans.length > localBestState.plans.length ||
+            (state.plans.length === localBestState.plans.length &&
+              state.failedBusIds.length < localBestState.failedBusIds.length)
+          ) {
+            localBestState = state
+          }
+          if (state.failedBusIds.length === 0) return state
+          const failedBusIds = new Set(state.failedBusIds)
+          planeOrder = [
+            ...state.failedBusIds.flatMap((busId) => {
+              const bus = planeBusById.get(busId)
+              return bus ? [bus] : []
+            }),
+            ...planeOrder.filter((bus) => !failedBusIds.has(bus.busId)),
+          ]
+        }
+      }
+      mostRecentBoundaryBestState = localBestState
+      return null
+    }
+
+    // Most dense packages route with the first deterministic boundary choice.
+    // Try that cheap path before widening the beam; eagerly generating four
+    // complete A* variants per state can otherwise dominate runtime and memory.
+    for (const alternativesPerBoundaryBus of [1, 4]) {
+      const states = getBoundaryStates(alternativesPerBoundaryBus)
+      if (!states) continue
+      const completeState = evaluateBoundaryStates(states, planeBuses)
+      if (completeState) return completeState
+
+      // If a completed signal escape encloses one especially constrained
+      // power pad, seed just that failed singleton first and recompute the
+      // small boundary-bus set around its physical through barrel. This keeps
+      // the search local without routing hundreds of plane drops before the
+      // signal buses.
+      const seedFailureIds = (
+        bestState as MixedTerminationState | null
+      )?.failedBusIds.slice(0, 3)
+      if (alternativesPerBoundaryBus === 1 && seedFailureIds) {
+        for (const failedBusId of seedFailureIds) {
+          const seededPlanePlans: FanoutRoutePlan[] = []
+          const seededPlaneBusIds = new Set<string>()
+          let nextFailedBusId: string | undefined = failedBusId
+          for (
+            let seedDepth = 0;
+            seedDepth < 3 && nextFailedBusId;
+            seedDepth++
+          ) {
+            const failedPlaneBus = planeBusById.get(nextFailedBusId)
+            if (!failedPlaneBus) break
+            const nextSeedPlans = routePlaneBus(
+              failedPlaneBus,
+              seededPlanePlans,
+            )
+            if (!nextSeedPlans) break
+            seededPlanePlans.push(...nextSeedPlans)
+            seededPlaneBusIds.add(nextFailedBusId)
+            const jointReservedBoundaryState =
+              getJointReservedBoundaryState(seededPlanePlans)
+            if (!jointReservedBoundaryState) break
+            const jointCompleteState = evaluateBoundaryStates(
+              [jointReservedBoundaryState],
+              planeBuses.filter((bus) => !seededPlaneBusIds.has(bus.busId)),
+            )
+            if (jointCompleteState) return jointCompleteState
+            const recentFailedBusIds = (
+              mostRecentBoundaryBestState as MixedTerminationState | null
+            )?.failedBusIds
+            nextFailedBusId = recentFailedBusIds?.find(
+              (busId) => !seededPlaneBusIds.has(busId),
+            )
+          }
+          if (seededPlanePlans.length === 0) continue
+          const seededBoundaryStates = getBoundaryStates(1, seededPlanePlans)
+          if (!seededBoundaryStates) continue
+          const seededCompleteState = evaluateBoundaryStates(
+            seededBoundaryStates,
+            planeBuses.filter((bus) => !seededPlaneBusIds.has(bus.busId)),
+          )
+          if (seededCompleteState) return seededCompleteState
+        }
+      }
+    }
+
+    return bestState
+  }
+
   private evaluateAssignmentWithStrategy(
     assignmentIndex: number,
     busLayerAssignments: Readonly<Record<string, string>>,
@@ -723,8 +1587,11 @@ export class FanoutSolver extends BaseSolver {
         busLayerAssignments[b.busId] ?? "",
       )
       return (
-        Number(b.termination.type === "plane") -
-          Number(a.termination.type === "plane") ||
+        comparePlaneRoutingPriority(
+          a,
+          b,
+          this.config.allowBlindAndBuriedVias,
+        ) ||
         Number(bUsesCoordinatedWinding) - Number(aUsesCoordinatedWinding) ||
         (aUsesCoordinatedWinding && bUsesCoordinatedWinding
           ? bLayerIndex - aLayerIndex
@@ -744,8 +1611,23 @@ export class FanoutSolver extends BaseSolver {
       )
     })
 
+    const mixedTerminationState =
+      !useSingleLayerPushAndShove && routingStrategy === "default"
+        ? this.routeDenseThroughAllMixedTerminations({
+            busLayerAssignments,
+            busesInRoutingOrder,
+          })
+        : null
+
+    if (mixedTerminationState) {
+      plans = mixedTerminationState.plans
+      failedBusIds = mixedTerminationState.failedBusIds
+    }
+
     let routingPrefixKey = `${routingStrategy}|`
-    for (const bus of useSingleLayerPushAndShove ? [] : busesInRoutingOrder) {
+    for (const bus of useSingleLayerPushAndShove || mixedTerminationState
+      ? []
+      : busesInRoutingOrder) {
       const targetLayer = busLayerAssignments[bus.busId]
       if (!targetLayer) {
         throw new Error(
@@ -777,6 +1659,7 @@ export class FanoutSolver extends BaseSolver {
         viaHoleDiameter: this.config.viaHoleDiameter,
         clearance: this.config.clearance,
         compactBusTracks: this.config.compactBusTracks,
+        allowBlindAndBuriedVias: this.config.allowBlindAndBuriedVias,
         allowSameNetMerges: this.config.allowSameNetMerges,
         staticClearanceCache: this.routeStaticClearanceCache,
         blockingBusCounts: currentBusBlockingCounts,
@@ -870,7 +1753,6 @@ export class FanoutSolver extends BaseSolver {
       score,
       ...(validationIssues ? { validationIssues } : {}),
     }
-
     return {
       summary,
       plans,
@@ -972,8 +1854,11 @@ export class FanoutSolver extends BaseSolver {
           : (this.escapeLayersByBusId[b.busId]?.length ??
             this.config.escapeLayers.length)
       return (
-        Number(b.termination.type === "plane") -
-          Number(a.termination.type === "plane") ||
+        comparePlaneRoutingPriority(
+          a,
+          b,
+          this.config.allowBlindAndBuriedVias,
+        ) ||
         Number(bUsesCoordinatedWinding) - Number(aUsesCoordinatedWinding) ||
         (aUsesCoordinatedWinding && bUsesCoordinatedWinding
           ? getMaximumViaSpan(b) - getMaximumViaSpan(a)
@@ -1084,6 +1969,7 @@ export class FanoutSolver extends BaseSolver {
               viaHoleDiameter: this.config.viaHoleDiameter,
               clearance: this.config.clearance,
               compactBusTracks: this.config.compactBusTracks,
+              allowBlindAndBuriedVias: this.config.allowBlindAndBuriedVias,
               allowSameNetMerges: this.config.allowSameNetMerges,
               staticClearanceCache: this.routeStaticClearanceCache,
             },
@@ -1534,14 +2420,17 @@ export class FanoutSolver extends BaseSolver {
         `FanoutSolver: completed output failed validation: ${validation.issues[0]?.message ?? "unknown validation error"}`,
       )
     }
-    const finalSrj =
-      this.endpointCompletion?.simpleRouteJson ?? this.bestAttempt.outputSrj
+    const finalSrj = addViaLayerMetadataToSrj({
+      srj:
+        this.endpointCompletion?.simpleRouteJson ?? this.bestAttempt.outputSrj,
+      layerNames: this.config.layerNames,
+      allowBlindAndBuriedVias: this.config.allowBlindAndBuriedVias,
+    })
     const finalTraceById = new Map(
       (finalSrj.traces ?? []).map((trace) => [trace.pcb_trace_id, trace]),
     )
     return {
-      simpleRouteJson:
-        this.endpointCompletion?.simpleRouteJson ?? this.bestAttempt.outputSrj,
+      simpleRouteJson: finalSrj,
       fanoutTraces: this.bestAttempt.plans.flatMap((plan) => [
         finalTraceById.get(plan.trace.pcb_trace_id) ?? plan.trace,
         ...(plan.planeEndpointTrace
@@ -1551,7 +2440,9 @@ export class FanoutSolver extends BaseSolver {
             ]
           : []),
       ]),
-      completionTraces: this.endpointCompletion?.traces ?? [],
+      completionTraces: (this.endpointCompletion?.traces ?? []).map(
+        (trace) => finalTraceById.get(trace.pcb_trace_id) ?? trace,
+      ),
       ...(this.endpointCompletion
         ? { endpointCompletion: this.endpointCompletion.report }
         : {}),
@@ -1576,7 +2467,7 @@ export class FanoutSolver extends BaseSolver {
     }
   }
 
-  getOutputSimpleRouteJson(): SimpleRouteJson {
+  getOutputSimpleRouteJson(): SimpleRouteJsonWithFanoutPlanes {
     return this.getOutput().simpleRouteJson
   }