@tscircuit/fanout-solver 0.0.59 → 0.0.61

package/lib/fanout-solver.ts

@@ -5,7 +5,11 @@ import { refineAdaptivePlaneReservationCore } from "./refine-adaptive-plane-rese
 import { shouldUseAdaptiveDensePlaneRouting } from "./should-use-adaptive-dense-plane-routing"
 import { type GraphicsObject, mergeGraphics } from "graphics-debug"
 import { addViaLayerMetadataToSrj } from "./add-via-layer-metadata"
-import { getCornerBandSide, getExitEdgeForDirection } from "./boundary-exit"
+import {
+  getCornerBandSide,
+  getDirectionForExitEdge,
+  getExitEdgeForDirection,
+} from "./boundary-exit"
 import { buildOutputSimpleRouteJson } from "./build-output"
 import {
   type CompleteOriginalEndpointsResult,
@@ -19,6 +23,7 @@ import {
 import { matchBusPlanLengths } from "./match-bus-lengths"
 import {
   getComponentDogboneViaSiteCandidates,
+  getSingleDogboneViaSiteRepairs,
   matchComponentDogboneViaSites,
 } from "./match-component-dogbone-via-sites"
 import { connectionsShareElectricalNet } from "./net-identity"
@@ -463,6 +468,9 @@ function createInitialLayerAssignment(params: {
   escapeLayers: string[]
   escapeLayersByBusId: Readonly<Record<string, readonly string[]>>
   preferOrderedCoordinatedWindingLayers: boolean
+  traceWidth: number
+  viaDiameter: number
+  clearance: number
 }): Readonly<Record<string, string>> {
   const {
     buses,
@@ -509,10 +517,151 @@ function createInitialLayerAssignment(params: {
         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]!
+        // Preserve caller preferences when boundary corridors are free. A
+        // centered or turning bus with a common target layer can occupy the
+        // same boundary band, so prefer another legal layer for a wide route.
+        const cornerSide = getCornerBandSide(bus.exitEdge, bus.preferredExit)
+        const getBoundaryCongestion = (layer: string): number => {
+          if (!bus.exitEdge || bus.connections.length < 8) return 0
+          const horizontalEdge =
+            bus.exitEdge === "left" || bus.exitEdge === "right"
+          const axis = horizontalEdge ? "y" : "x"
+          const minimum = horizontalEdge
+            ? bus.sharedBoundary.minY
+            : bus.sharedBoundary.minX
+          const maximum = horizontalEdge
+            ? bus.sharedBoundary.maxY
+            : bus.sharedBoundary.maxX
+          if (!cornerSide) {
+            const tracks = bus.connections.map((connection) => {
+              const target =
+                connection.exitTargetPoint ?? connection.targetPoint
+              return Math.max(minimum, Math.min(maximum, target[axis]))
+            })
+            const bandMinimum = Math.min(...tracks)
+            const bandMaximum = Math.max(...tracks)
+            const forwardAxis = horizontalEdge ? "x" : "y"
+            const sign =
+              bus.exitEdge === "right" || bus.exitEdge === "top" ? 1 : -1
+            const sourceNearEnd = Math.min(
+              ...bus.connections.map(
+                (connection) => sign * connection.sourcePoint[forwardAxis],
+              ),
+            )
+            const sourceMinimum = Math.min(
+              ...bus.connections.map(
+                (connection) => connection.sourcePoint[axis],
+              ),
+            )
+            const sourceMaximum = Math.max(
+              ...bus.connections.map(
+                (connection) => connection.sourcePoint[axis],
+              ),
+            )
+            return buses.reduce((count, other) => {
+              const otherCorner = getCornerBandSide(
+                other.exitEdge,
+                other.preferredExit,
+              )
+              if (
+                other === bus ||
+                other.termination.type !== "boundary" ||
+                other.componentId !== bus.componentId ||
+                other.exitEdge !== bus.exitEdge ||
+                !otherCorner ||
+                getCommonExplicitExitTargetLayer(other) !== layer
+              )
+                return count
+              const center =
+                minimum +
+                (maximum - minimum) * (otherCorner === "minimum" ? 0.25 : 0.75)
+              const halfWidth =
+                ((Math.max(
+                  other.connections.length,
+                  other.cornerBandConnectionCount ?? 0,
+                ) -
+                  1) *
+                  Math.max(
+                    params.traceWidth + params.clearance,
+                    params.viaDiameter + params.clearance,
+                  )) /
+                2
+              const margin = params.traceWidth + params.clearance
+              const overlapsBoundaryBand =
+                bandMaximum + margin >= center - halfWidth &&
+                bandMinimum - margin <= center + halfWidth
+              // A turning bus behind this source field must also pass its lanes
+              // on the way to the edge, even when its final band is elsewhere.
+              const crossesSourceField =
+                Math.max(
+                  ...other.connections.map(
+                    (connection) => sign * connection.sourcePoint[forwardAxis],
+                  ),
+                ) <
+                  sourceNearEnd - 1e-9 &&
+                Math.min(
+                  ...other.connections.map(
+                    (connection) => connection.sourcePoint[axis],
+                  ),
+                ) <=
+                  sourceMaximum + margin &&
+                Math.max(
+                  ...other.connections.map(
+                    (connection) => connection.sourcePoint[axis],
+                  ),
+                ) >=
+                  sourceMinimum - margin
+              return (
+                count +
+                (overlapsBoundaryBand || crossesSourceField
+                  ? other.connections.length
+                  : 0)
+              )
+            }, 0)
+          }
+          const bandCenter =
+            minimum +
+            (maximum - minimum) * (cornerSide === "minimum" ? 0.25 : 0.75)
+          const pitch = Math.max(
+            params.traceWidth + params.clearance,
+            params.viaDiameter + params.clearance,
+          )
+          const bandHalfWidth =
+            ((Math.max(
+              bus.connections.length,
+              bus.cornerBandConnectionCount ?? 0,
+            ) -
+              1) *
+              pitch) /
+            2
+          return buses.reduce((count, other) => {
+            if (
+              other === bus ||
+              other.termination.type !== "boundary" ||
+              other.componentId !== bus.componentId ||
+              other.exitEdge !== bus.exitEdge ||
+              getCornerBandSide(other.exitEdge, other.preferredExit) ||
+              getCommonExplicitExitTargetLayer(other) !== layer
+            )
+              return count
+            return (
+              count +
+              other.connections.filter((connection) => {
+                const target =
+                  connection.exitTargetPoint ?? connection.targetPoint
+                const track = Math.max(minimum, Math.min(maximum, target[axis]))
+                return (
+                  Math.abs(track - bandCenter) <=
+                  bandHalfWidth + params.traceWidth + params.clearance
+                )
+              }).length
+            )
+          }, 0)
+        }
+        assignment[bus.busId] = viaLayers.toSorted(
+          (first, second) =>
+            getBoundaryCongestion(first) - getBoundaryCongestion(second),
+        )[0]!
         continue
       }
       const componentDirections = directionsByComponent.get(bus.componentId)!
@@ -1042,6 +1191,9 @@ export class FanoutSolver extends BaseSolver {
           buses: this.preparedBuses,
           escapeLayers: this.config.escapeLayers,
           escapeLayersByBusId: this.escapeLayersByBusId,
+          traceWidth: this.config.traceWidth,
+          viaDiameter: this.config.viaDiameter,
+          clearance: this.config.clearance,
           preferOrderedCoordinatedWindingLayers:
             this.config.densePlaneReservationBusIds.length > 0 ||
             this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0 ||
@@ -1482,6 +1634,64 @@ export class FanoutSolver extends BaseSolver {
     const wideBoundaryBuses = unsortedBoundaryBuses.filter(
       (bus) => bus.connections.length >= 8,
     )
+    // A single-layer turning bus beside the end of a centered source field
+    // has fewer escape choices than a corner bus farther behind it. Reserve
+    // that turning channel before the farther bus fences its local via sites.
+    const adjacentCenteredFieldByTurningBus = new Map<
+      PreparedBus,
+      PreparedBus
+    >()
+    if (usePadAlignedDenseRouting && !configuredDensePlaneRouting) {
+      for (const bus of wideBoundaryBuses) {
+        if (
+          !getCornerBandSide(bus.exitEdge, bus.preferredExit) ||
+          new Set(bus.routableEscapeLayers ?? bus.allowedLayers ?? []).size !==
+            1
+        )
+          continue
+        const axis =
+          bus.direction === "up" || bus.direction === "down" ? "y" : "x"
+        const track = axis === "x" ? "y" : "x"
+        const sign =
+          bus.direction === "up" || bus.direction === "right" ? 1 : -1
+        const forwardEnd = Math.max(
+          ...bus.connections.map((c) => sign * c.sourcePoint[axis]),
+        )
+        const minTrack = Math.min(
+          ...bus.connections.map((c) => c.sourcePoint[track]),
+        )
+        const maxTrack = Math.max(
+          ...bus.connections.map((c) => c.sourcePoint[track]),
+        )
+        const pitch = axis === "x" ? bus.pitchX : bus.pitchY
+        const field = wideBoundaryBuses.find((candidate) => {
+          if (
+            candidate === bus ||
+            candidate.componentId !== bus.componentId ||
+            candidate.exitEdge !== bus.exitEdge ||
+            getCornerBandSide(candidate.exitEdge, candidate.preferredExit)
+          )
+            return false
+          const nearEnd = Math.min(
+            ...candidate.connections.map((c) => sign * c.sourcePoint[axis]),
+          )
+          const gap = nearEnd - forwardEnd
+          return (
+            gap >= -1e-9 &&
+            gap <= pitch + 1e-9 &&
+            Math.min(
+              ...candidate.connections.map((c) => c.sourcePoint[track]),
+            ) <=
+              maxTrack + 1e-9 &&
+            Math.max(
+              ...candidate.connections.map((c) => c.sourcePoint[track]),
+            ) >=
+              minTrack - 1e-9
+          )
+        })
+        if (field) adjacentCenteredFieldByTurningBus.set(bus, field)
+      }
+    }
     const hasThreeWideBoundaryBuses =
       useConfiguredDensePlaneRouting && wideBoundaryBuses.length === 3
     const getBoundaryTargetSpan = (bus: PreparedBus) => {
@@ -1982,14 +2192,35 @@ export class FanoutSolver extends BaseSolver {
         : []),
       ...singletonDeferralCandidates.filter((bus) => {
         const containingBus = getContainingWideSourceField(bus)
-        const sharesContainingBusLayer =
+        const sourcePoint = bus.connections[0]!.sourcePoint
+        const componentCenter = {
+          x: (bus.componentBounds.minX + bus.componentBounds.maxX) / 2,
+          y: (bus.componentBounds.minY + bus.componentBounds.maxY) / 2,
+        }
+        const boundaryDirection = bus.exitEdge
+          ? getDirectionForExitEdge(bus.exitEdge)
+          : bus.direction
+        const inwardProjection =
+          boundaryDirection === "right"
+            ? componentCenter.x - sourcePoint.x
+            : boundaryDirection === "left"
+              ? sourcePoint.x - componentCenter.x
+              : boundaryDirection === "up"
+                ? componentCenter.y - sourcePoint.y
+                : sourcePoint.y - componentCenter.y
+        // Crossing the component can consume an embedded singleton's source
+        // dogbone even when the target layers differ. Keep outward boundary
+        // escapes provisional unless they share the wide bus's target layer.
+        const reserveEmbeddedSourceEscape =
           usePadAlignedDenseRouting &&
           !useConfiguredDensePlaneRouting &&
           containingBus &&
-          params.busLayerAssignments[containingBus.busId] ===
-            params.busLayerAssignments[bus.busId]
+          (params.busLayerAssignments[containingBus.busId] ===
+            params.busLayerAssignments[bus.busId] ||
+            inwardProjection > 1e-9)
         return (
-          !leadingWideSingletonBuses.includes(bus) && !sharesContainingBusLayer
+          !leadingWideSingletonBuses.includes(bus) &&
+          !reserveEmbeddedSourceEscape
         )
       }),
       ...(hasThreeWideBoundaryBuses
@@ -2164,6 +2395,167 @@ export class FanoutSolver extends BaseSolver {
             bus,
           ]),
       ]
+      for (const [bus] of adjacentCenteredFieldByTurningBus) {
+        const axis =
+          bus.direction === "up" || bus.direction === "down" ? "y" : "x"
+        const sign =
+          bus.direction === "up" || bus.direction === "right" ? 1 : -1
+        const backwardEnd = Math.min(
+          ...bus.connections.map(
+            (connection) => sign * connection.sourcePoint[axis],
+          ),
+        )
+        const index = denseBoundaryBusesInRoutingOrder.indexOf(bus)
+        const earlierCornerIndex = denseBoundaryBusesInRoutingOrder.findIndex(
+          (candidate) =>
+            candidate !== bus &&
+            candidate.connections.length >= 8 &&
+            candidate.componentId === bus.componentId &&
+            candidate.direction === bus.direction &&
+            Math.max(
+              ...candidate.connections.map(
+                (connection) => sign * connection.sourcePoint[axis],
+              ),
+            ) <=
+              backwardEnd + 1e-9 &&
+            candidate.exitEdge === bus.exitEdge &&
+            getCornerBandSide(candidate.exitEdge, candidate.preferredExit) ===
+              getCornerBandSide(bus.exitEdge, bus.preferredExit),
+        )
+        if (earlierCornerIndex >= 0 && earlierCornerIndex < index) {
+          denseBoundaryBusesInRoutingOrder.splice(index, 1)
+          denseBoundaryBusesInRoutingOrder.splice(earlierCornerIndex, 0, bus)
+        }
+      }
+      const areAdjacentInvertedNarrowBuses = (
+        first: PreparedBus,
+        second: PreparedBus,
+      ): boolean => {
+        if (
+          !usePadAlignedDenseRouting ||
+          first.componentId !== second.componentId ||
+          first.exitEdge !== second.exitEdge ||
+          first.direction !== second.direction ||
+          getCornerBandSide(first.exitEdge, first.preferredExit) !==
+            getCornerBandSide(second.exitEdge, second.preferredExit) ||
+          params.busLayerAssignments[first.busId] !==
+            params.busLayerAssignments[second.busId] ||
+          getContainingWideSourceField(first) !==
+            getContainingWideSourceField(second) ||
+          !getContainingWideSourceField(first)
+        )
+          return false
+        const firstCenter = {
+          x:
+            first.connections.reduce(
+              (sum, connection) => sum + connection.sourcePoint.x,
+              0,
+            ) / first.connections.length,
+          y:
+            first.connections.reduce(
+              (sum, connection) => sum + connection.sourcePoint.y,
+              0,
+            ) / first.connections.length,
+        }
+        const secondCenter = {
+          x:
+            second.connections.reduce(
+              (sum, connection) => sum + connection.sourcePoint.x,
+              0,
+            ) / second.connections.length,
+          y:
+            second.connections.reduce(
+              (sum, connection) => sum + connection.sourcePoint.y,
+              0,
+            ) / second.connections.length,
+        }
+        if (
+          Math.hypot(
+            firstCenter.x - secondCenter.x,
+            firstCenter.y - secondCenter.y,
+          ) >
+          1.5 * Math.min(first.pitchX, first.pitchY)
+        )
+          return false
+        const axis =
+          first.exitEdge === "left" || first.exitEdge === "right" ? "y" : "x"
+        const targetTrack = (bus: PreparedBus) =>
+          bus.connections.reduce(
+            (sum, connection) =>
+              sum +
+              (connection.exitTargetPoint ?? connection.targetPoint)[axis],
+            0,
+          ) / bus.connections.length
+        return (
+          (firstCenter[axis] - secondCenter[axis]) *
+            (targetTrack(first) - targetTrack(second)) <
+          -1e-9
+        )
+      }
+      // Preserve a centered pair's channel before its leading singleton. A
+      // turning pair instead leaves its adjacent singleton room to escape
+      // before searching for an outside-package via.
+      const centeredPairPromotionGroups = new Set<string>()
+      for (const singleton of leadingWideSingletonBuses) {
+        if (getCornerBandSide(singleton.exitEdge, singleton.preferredExit))
+          continue
+        for (const pair of boundaryBuses) {
+          if (
+            pair.connections.length !== 2 ||
+            !areAdjacentInvertedNarrowBuses(pair, singleton)
+          )
+            continue
+          const pairIndex = denseBoundaryBusesInRoutingOrder.indexOf(pair)
+          const singletonIndex =
+            denseBoundaryBusesInRoutingOrder.indexOf(singleton)
+          if (pairIndex > singletonIndex) {
+            denseBoundaryBusesInRoutingOrder.splice(pairIndex, 1)
+            denseBoundaryBusesInRoutingOrder.splice(singletonIndex, 0, pair)
+            centeredPairPromotionGroups.add(
+              `${pair.componentId}:${pair.exitEdge}`,
+            )
+          }
+        }
+      }
+      for (const pair of boundaryBuses) {
+        if (
+          !centeredPairPromotionGroups.has(
+            `${pair.componentId}:${pair.exitEdge}`,
+          ) ||
+          pair.connections.length !== 2 ||
+          !getCornerBandSide(pair.exitEdge, pair.preferredExit)
+        )
+          continue
+        for (const singleton of singletonBoundaryBuses) {
+          if (!areAdjacentInvertedNarrowBuses(singleton, pair)) continue
+          const singletonIndex =
+            denseBoundaryBusesInRoutingOrder.indexOf(singleton)
+          const pairIndex = denseBoundaryBusesInRoutingOrder.indexOf(pair)
+          if (singletonIndex > pairIndex) {
+            denseBoundaryBusesInRoutingOrder.splice(singletonIndex, 1)
+            denseBoundaryBusesInRoutingOrder.splice(pairIndex, 0, singleton)
+          }
+        }
+      }
+      for (const field of adjacentCenteredFieldByTurningBus.values()) {
+        for (const pair of boundaryBuses) {
+          if (
+            pair.connections.length !== 2 ||
+            getContainingWideSourceField(pair) !== field
+          )
+            continue
+          for (const singleton of singletonBoundaryBuses) {
+            if (!areAdjacentInvertedNarrowBuses(singleton, pair)) continue
+            const pairIndex = denseBoundaryBusesInRoutingOrder.indexOf(pair)
+            const singletonIndex =
+              denseBoundaryBusesInRoutingOrder.indexOf(singleton)
+            if (singletonIndex > pairIndex) {
+              denseBoundaryBusesInRoutingOrder.splice(singletonIndex, 1)
+              denseBoundaryBusesInRoutingOrder.splice(pairIndex, 0, singleton)
+            }
+          }
+        }
+      }
       let fixedViaPointsByConnectionIndex: ReadonlyMap<
         number,
         { x: number; y: number }
@@ -2311,6 +2703,7 @@ export class FanoutSolver extends BaseSolver {
           useConfiguredDensePlaneRouting &&
           singleLayerBus !== bus &&
           !embeddedNarrowBusAlreadyRouted
+        let usedRepairedViaSites = false
         let busPlans = (yield* routeAlternatives(
           preferSingleLayerWinding
             ? { ...routeParams, bus: singleLayerBus }
@@ -2417,6 +2810,197 @@ export class FanoutSolver extends BaseSolver {
             }
           }
         }
+        // A first turning bus can be fenced by one diagonal site even though
+        // every provisional dogbone is individually legal. Try moving one of
+        // its own sites while retaining all other through-via reservations.
+        // Keep this bounded repair ahead of the broader free-site search.
+        if (
+          !busPlans &&
+          useAdaptiveDensePlaneRouting &&
+          bus.connections.length >= 8 &&
+          getCornerBandSide(bus.exitEdge, bus.preferredExit) &&
+          new Set(bus.routableEscapeLayers ?? bus.allowedLayers ?? []).size ===
+            1 &&
+          !matchedPlans.some((plan) =>
+            wideBoundaryBuses.some(
+              (candidate) => candidate.busId === plan.busId,
+            ),
+          )
+        ) {
+          const reservedVias = getReservedVias(bus)
+          const siteRepairs = getSingleDogboneViaSiteRepairs(
+            bus,
+            {
+              viaDiameter: this.config.viaDiameter,
+              viaHoleDiameter: this.config.viaHoleDiameter,
+              traceWidth: this.config.traceWidth,
+              clearance: this.config.clearance,
+              additionalObstacles: this.routingSrj.obstacles,
+              blockingSegments: [
+                ...matchedPlans.flatMap((plan) =>
+                  plan.segments.map((segment) => ({
+                    connectionIndex: plan.connectionIndex,
+                    segment,
+                  })),
+                ),
+                ...reservedVias.flatMap((reserved) =>
+                  reserved.sourceEscapeSegment
+                    ? [
+                        {
+                          connectionIndex: -1,
+                          segment: reserved.sourceEscapeSegment,
+                        },
+                      ]
+                    : [],
+                ),
+              ],
+              blockingVias: [
+                ...matchedPlans.flatMap((plan) =>
+                  plan.via
+                    ? [{ connectionIndex: plan.connectionIndex, ...plan.via }]
+                    : [],
+                ),
+                ...reservedVias.map((reserved) => ({
+                  connectionIndex: -1,
+                  ...reserved.via,
+                })),
+              ],
+            },
+            fixedViaPointsByConnectionIndex,
+          )
+          for (const replacementPoints of siteRepairs) {
+            const replacementPlans = (yield* routeAlternatives(
+              {
+                ...routeParams,
+                fixedViaPointsByConnectionIndex: replacementPoints,
+                reservedVias,
+                fixedViaFallbackRouteOrderAttempts: 1,
+              },
+              1,
+            ))[0]
+            if (!replacementPlans) continue
+            busPlans = replacementPlans
+            fixedViaPointsByConnectionIndex = replacementPoints
+            usedRepairedViaSites = true
+            break
+          }
+        }
+        // Fixed dogbones can close a turning bus's own escape channel. Retry
+        // local sites while retaining every other connection's reservations.
+        if (
+          !busPlans &&
+          useAdaptiveDensePlaneRouting &&
+          bus.connections.length >= 8 &&
+          getCornerBandSide(bus.exitEdge, bus.preferredExit)
+        ) {
+          busPlans = (yield* routeAlternatives(
+            {
+              ...routeParams,
+              fixedViaPointsByConnectionIndex: undefined,
+              reservedVias: getReservedVias(bus),
+            },
+            1,
+          ))[0]
+          if (busPlans) {
+            usedRepairedViaSites = true
+            fixedViaPointsByConnectionIndex = new Map([
+              ...fixedViaPointsByConnectionIndex,
+              ...busPlans
+                .filter((plan) => plan.via)
+                .map(
+                  (plan) => [plan.connectionIndex, plan.via!.center] as const,
+                ),
+            ])
+          }
+          debugDense("local-sites", bus.busId, busPlans?.length ?? "failed")
+        }
+        // Retry a blocked wide bus with provisional plane sites as search
+        // costs. A turning bus beside a centered field may also need that
+        // neighboring field's uncommitted sites to move. Keep every committed
+        // route and narrow reservation hard, then require a complete rematch.
+        if (
+          !busPlans &&
+          bus.connections.length >= 8 &&
+          (adjacentCenteredFieldByTurningBus.has(bus) ||
+            boundaryBuses.some(
+              (candidate) =>
+                candidate.connections.length >= 8 &&
+                matchedPlans.some((plan) => plan.busId === candidate.busId),
+            ))
+        ) {
+          const committedNames = new Set(
+            matchedPlans.map((plan) => plan.connectionName),
+          )
+          const provisionalReservationNames = new Set(
+            this.preparedBuses
+              .filter(
+                (candidate) =>
+                  candidate.termination.type === "plane" ||
+                  candidate === adjacentCenteredFieldByTurningBus.get(bus),
+              )
+              .flatMap((candidate) =>
+                candidate.connections.map(
+                  (connection) => connection.connection.name,
+                ),
+              )
+              .filter((name) => !committedNames.has(name)),
+          )
+          const freePlans = (yield* routeAlternatives(
+            {
+              ...routeParams,
+              fixedViaPointsByConnectionIndex: undefined,
+              reservedVias: routeParams.reservedVias.filter(
+                (reserved) =>
+                  !provisionalReservationNames.has(reserved.connectionName),
+              ),
+              softReservedVias: routeParams.reservedVias.filter((reserved) =>
+                provisionalReservationNames.has(reserved.connectionName),
+              ),
+            },
+            1,
+          ))[0]
+          if (freePlans) {
+            const allPlans = [...matchedPlans, ...freePlans]
+            const rematchedPoints = matchComponentDogboneViaSites(
+              this.preparedBuses,
+              {
+                viaDiameter: this.config.viaDiameter,
+                viaHoleDiameter: this.config.viaHoleDiameter,
+                traceWidth: this.config.traceWidth,
+                clearance: this.config.clearance,
+                maximumSearchStates: 3_000_000,
+                preferredBoundaryPerpendicularSideByBusId,
+                preferBoundaryOutwardByBusId,
+                fixedViaPointsByConnectionIndex: new Map(
+                  allPlans
+                    .filter((plan) => plan.via)
+                    .map((plan) => [plan.connectionIndex, plan.via!.center]),
+                ),
+                preferredViaPointsByConnectionIndex:
+                  fixedViaPointsByConnectionIndex,
+                blockingSegments: allPlans.flatMap((plan) =>
+                  plan.segments.map((segment) => ({
+                    connectionIndex: plan.connectionIndex,
+                    segment,
+                  })),
+                ),
+                additionalObstacles: this.routingSrj.obstacles,
+                preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+                canShareCopper,
+              },
+            )
+            debugDense(
+              "free-sites:rematched",
+              bus.busId,
+              rematchedPoints?.size ?? "failed",
+            )
+            if (rematchedPoints) {
+              busPlans = freePlans
+              fixedViaPointsByConnectionIndex = rematchedPoints
+              usedRepairedViaSites = true
+            }
+          }
+        }
         if (busPlans && bus.maxLengthSkew !== undefined) {
           const lengths = busPlans.map((plan) => plan.length)
           const rawSkew = Math.max(...lengths) - Math.min(...lengths)
@@ -2430,7 +3014,13 @@ export class FanoutSolver extends BaseSolver {
           // 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 && !matchLengthsAfterPlanes) {
+          // Keep repaired via sites: routeParams still carries the
+          // earlier provisional sites and cannot safely replace its geometry.
+          if (
+            needsRouteDiversity &&
+            !matchLengthsAfterPlanes &&
+            !usedRepairedViaSites
+          ) {
             busPlans = (yield* routeAlternatives(routeParams, 3)).toSorted(
               (first, second) => {
                 const firstLengths = first.map((plan) => plan.length)

package/lib/match-bus-lengths.ts

@@ -338,9 +338,33 @@ function replacementCopperIsSelfClear(params: {
       ) {
         continue
       }
+      const viaClearance = via.diameter / 2 + replacement.width / 2 + clearance
+      // An off-grid via can join this run through a short, connected stub.
+      // Preserve that existing connection while rejecting later approaches.
+      const connectsThroughShortStub = (direction: -1 | 1): boolean => {
+        let point = direction === -1 ? replacement.start : replacement.end
+        let pathDistance = 0
+        for (
+          let index = replacementIndex + direction;
+          index >= 0 && index < segments.length;
+          index += direction
+        ) {
+          const segment = segments[index]!
+          if (segment.layer !== replacement.layer) return false
+          const connectedEnd = direction === -1 ? segment.end : segment.start
+          if (!pointsMatch(point, connectedEnd)) return false
+          pathDistance += distance(segment.start, segment.end)
+          if (pathDistance > viaClearance + EPSILON) return false
+          point = direction === -1 ? segment.start : segment.end
+          if (pointsMatch(point, via.center)) return true
+        }
+        return false
+      }
       if (
         distancePointToSegment(via.center, replacement.start, replacement.end) <
-        via.diameter / 2 + replacement.width / 2 + clearance - EPSILON
+          viaClearance - EPSILON &&
+        !connectsThroughShortStub(-1) &&
+        !connectsThroughShortStub(1)
       ) {
         return false
       }

package/lib/match-component-dogbone-via-sites.ts

@@ -782,3 +782,30 @@ export function getComponentDogboneViaSiteCandidates(
     ),
   )
 }
+
+/** Try one adjacent site change without releasing any other fixed via. */
+export function* getSingleDogboneViaSiteRepairs(
+  bus: PreparedBus,
+  rules: DogboneViaSiteGeometryRules,
+  fixedViaPointsByConnectionIndex: ReadonlyMap<number, Point2D>,
+): Generator<ReadonlyMap<number, Point2D>, void, unknown> {
+  const sites = getComponentDogboneViaSiteCandidates([bus], rules)
+  let remainingAttempts = 24
+  for (const connection of bus.connections.toReversed()) {
+    const original = fixedViaPointsByConnectionIndex.get(
+      connection.connectionIndex,
+    )
+    if (!original) continue
+    for (const candidate of sites) {
+      if (
+        candidate.connectionIndex !== connection.connectionIndex ||
+        distance(candidate.point, original) <= EPSILON
+      )
+        continue
+      if (remainingAttempts-- <= 0) return
+      const replacement = new Map(fixedViaPointsByConnectionIndex)
+      replacement.set(connection.connectionIndex, candidate.point)
+      yield replacement
+    }
+  }
+}

package/lib/route-bus.ts

@@ -62,6 +62,8 @@ export interface RouteBusParams {
   stopAfterFirstRejectedViaMinimalCandidate?: boolean
   fixedViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
   reservedVias?: readonly ViaMinimalWindingReservedVia[]
+  /** Provisional site preferences; successful callers must rematch future vias. */
+  softReservedVias?: readonly ViaMinimalWindingReservedVia[]
   viaMinimalOnly?: boolean
   /** Permit a singleton or pair to move provisional vias near the boundary. */
   allowBoundarySideViaFallback?: boolean
@@ -163,6 +165,7 @@ function getWindingTargetOrders(params: {
 }): {
   orders: PreparedConnection[][]
   legacyOrder: PreparedConnection[]
+  ordinaryOrderCount: number
 } {
   const { bus, boundaryDirection, layerNames, targetLayer } = params
   const getTargetLayer = (candidate: PreparedConnection): string =>
@@ -266,6 +269,41 @@ function getWindingTargetOrders(params: {
   // but do not let sub-nanometer noise between unrelated layer bands choose
   // the primary topology.
   candidateOrders.push(legacyOrderedConnections)
+  const ordinaryOrderCount = new Set(
+    candidateOrders.map((order) =>
+      order.map((candidate) => candidate.connectionIndex).join(","),
+    ),
+  ).size
+  // Preserve each original layer's lane order while exploring other legal
+  // interleavings. Keep this bounded for buses with many source layers.
+  if (
+    !getCornerSide(bus) &&
+    bus.connections.length <= 8 &&
+    orderedLayers.length > 1
+  ) {
+    const layerSequences = orderedLayers.map((layer) =>
+      connectionsByLayer.get(layer)!.toSorted(compareWithinLayer),
+    )
+    const offsets = layerSequences.map(() => 0)
+    const current: PreparedConnection[] = []
+    const append = (): void => {
+      if (candidateOrders.length >= 128) return
+      if (current.length === bus.connections.length) {
+        candidateOrders.push([...current])
+        return
+      }
+      for (let layer = 0; layer < layerSequences.length; layer++) {
+        const next = layerSequences[layer]![offsets[layer]!]
+        if (!next) continue
+        offsets[layer]++
+        current.push(next)
+        append()
+        current.pop()
+        offsets[layer]--
+      }
+    }
+    append()
+  }
   const seenOrders = new Set<string>()
   const orders = candidateOrders.filter((order) => {
     const key = order.map((candidate) => candidate.connectionIndex).join(",")
@@ -273,7 +311,7 @@ function getWindingTargetOrders(params: {
     seenOrders.add(key)
     return true
   })
-  return { orders, legacyOrder: legacyOrderedConnections }
+  return { orders, legacyOrder: legacyOrderedConnections, ordinaryOrderCount }
 }
 
 function getWindingTargetRank(params: {
@@ -311,10 +349,92 @@ function getWindingCrossoverLayer(params: {
   )
 }
 
+function getDistributedBoundaryTargetTracks(params: {
+  bus: PreparedBus
+  boundaryDirection: FanoutDirection
+  traceWidth: number
+  clearance: number
+  allowLayerInterleaving?: boolean
+}): number[] | undefined {
+  const { bus, boundaryDirection, traceWidth, clearance } = params
+  if (getCornerSide(bus) || !busUsesCoordinatedWindingChannel(bus))
+    return undefined
+  const layers = new Set(
+    bus.connections.map(
+      (connection) =>
+        connection.exitTargetPoint?.layer ??
+        getPointLayer(connection.targetPoint),
+    ),
+  )
+  if (layers.size < 2) return undefined
+  const minimum = isHorizontal(boundaryDirection)
+    ? bus.sharedBoundary.minY
+    : bus.sharedBoundary.minX
+  const maximum = isHorizontal(boundaryDirection)
+    ? bus.sharedBoundary.maxY
+    : bus.sharedBoundary.maxX
+  const tracks = bus.connections
+    .map((connection) =>
+      Math.max(
+        minimum,
+        Math.min(
+          maximum,
+          getPerpendicularAxis(
+            connection.exitTargetPoint ?? connection.targetPoint,
+            boundaryDirection,
+          ),
+        ),
+      ),
+    )
+    .toSorted((a, b) => a - b)
+  const pitch = traceWidth + clearance
+  if (
+    !params.allowLayerInterleaving &&
+    tracks.every(
+      (track, index) =>
+        index === 0 || track - tracks[index - 1]! >= pitch - 1e-9,
+    )
+  )
+    return undefined
+  if (maximum - minimum < (tracks.length - 1) * pitch - 1e-9) return undefined
+  // Pool neighboring overlaps while preserving their mean requested location.
+  // Subtracting the pitch reduces the clearance constraint to monotonicity.
+  const blocks: { start: number; count: number; mean: number }[] = []
+  for (const [index, track] of tracks.entries()) {
+    blocks.push({ start: index, count: 1, mean: track - index * pitch })
+    while (blocks.length > 1 && blocks.at(-2)!.mean > blocks.at(-1)!.mean) {
+      const second = blocks.pop()!
+      const first = blocks.pop()!
+      blocks.push({
+        start: first.start,
+        count: first.count + second.count,
+        mean:
+          (first.mean * first.count + second.mean * second.count) /
+          (first.count + second.count),
+      })
+    }
+  }
+  for (const block of blocks) {
+    const mean = Math.max(
+      minimum,
+      Math.min(maximum - (tracks.length - 1) * pitch, block.mean),
+    )
+    for (let index = block.start; index < block.start + block.count; index++)
+      tracks[index] = mean + index * pitch
+  }
+  return tracks
+}
+
 export function getBoundaryTargetTrack(params: {
   bus: PreparedBus
   connection: PreparedConnection
   boundaryDirection: FanoutDirection
+  traceWidth?: number
+  clearance?: number
+  layerNames?: readonly string[]
+  targetLayer?: string
+  windingOrderIndex?: number
+  allowLayerInterleaving?: boolean
 }): number {
   const requestedTrack = getPerpendicularAxis(
     params.connection.exitTargetPoint ?? params.connection.targetPoint,
@@ -326,6 +446,22 @@ export function getBoundaryTargetTrack(params: {
   const boundaryMaximum = isHorizontal(params.boundaryDirection)
     ? params.bus.sharedBoundary.maxY
     : params.bus.sharedBoundary.maxX
+  const distributedTracks =
+    params.traceWidth !== undefined && params.clearance !== undefined
+      ? getDistributedBoundaryTargetTracks({
+          ...params,
+          traceWidth: params.traceWidth,
+          clearance: params.clearance,
+        })
+      : undefined
+  if (distributedTracks && params.layerNames && params.targetLayer) {
+    const { rank } = getWindingTargetRank({
+      ...params,
+      layerNames: params.layerNames,
+      targetLayer: params.targetLayer,
+    })
+    return distributedTracks[rank]!
+  }
   return Math.max(boundaryMinimum, Math.min(boundaryMaximum, requestedTrack))
 }
 
@@ -1102,6 +1238,10 @@ function buildPlan(params: {
             bus,
             connection: preparedConnection,
             boundaryDirection,
+            traceWidth,
+            clearance,
+            layerNames,
+            targetLayer,
           })
         : track
   const connectionRank = getConnectionRank(bus, preparedConnection)
@@ -2459,6 +2599,7 @@ export function* routeBusAlternativesSteps(
     stopAfterFirstRejectedViaMinimalCandidate = false,
     fixedViaPointsByConnectionIndex,
     reservedVias = [],
+    softReservedVias = [],
     viaMinimalOnly = false,
     allowBoundarySideViaFallback = false,
     preferCornerBoundaryVia = false,
@@ -2606,15 +2747,29 @@ export function* routeBusAlternativesSteps(
       windingOrderIndex?: number
       preferTargetDirectedLaneBias?: boolean
       localDogboneRepair?: boolean
+      reserveTerminalExitPoints?: boolean
+      cornerExitLaneOffset?: number
+      allowLayerInterleaving?: boolean
     }
     const maximumThroughAllRouteOrderAttempts = 24
-    const windingTargetOrderCount = cornerSide
-      ? getWindingTargetOrders({
+    const usesDistributedWindingTargets = Boolean(
+      cornerSide ||
+        getDistributedBoundaryTargetTracks({
           bus,
           boundaryDirection,
-          layerNames,
-          targetLayer,
-        }).orders.length
+          traceWidth,
+          clearance,
+        }),
+    )
+    const windingTargetOrders = getWindingTargetOrders({
+      bus,
+      boundaryDirection,
+      layerNames,
+      targetLayer,
+    })
+    const windingTargetOrderCount = windingTargetOrders.orders.length
+    const ordinaryWindingTargetOrderCount = usesDistributedWindingTargets
+      ? windingTargetOrders.ordinaryOrderCount
       : 1
     const uniformDogboneTerminalPatterns: CoordinatedTerminalPattern[] =
       viaHandednesses.map((viaHandedness) => ({
@@ -2760,7 +2915,13 @@ export function* routeBusAlternativesSteps(
     const coordinatedViaPoints =
       fixedViaPointsByConnectionIndex ??
       (!allowBlindAndBuriedVias &&
-      bus.connections.length >= 8 &&
+      (bus.connections.length >= 8 ||
+        getDistributedBoundaryTargetTracks({
+          bus,
+          boundaryDirection,
+          traceWidth,
+          clearance,
+        })) &&
       reservedVias.length === 0
         ? matchComponentDogboneViaSites([bus], {
             viaDiameter,
@@ -2789,7 +2950,7 @@ export function* routeBusAlternativesSteps(
       coordinatedViaPoints
         ? [
             ...Array.from(
-              { length: windingTargetOrderCount },
+              { length: ordinaryWindingTargetOrderCount },
               (_, windingOrderIndex) => ({
                 label: `component-matched-vias-winding-${windingOrderIndex}`,
                 useViaInPad: false,
@@ -2813,6 +2974,26 @@ export function* routeBusAlternativesSteps(
               windingOrderIndex: 0,
               preferTargetDirectedLaneBias: true,
             },
+            // Keep ordinary fixed-site attempts first. Forward retries reserve
+            // future exits so an earlier lane cannot close their final gap.
+            ...(!getCornerSide(bus) && windingTargetOrderCount > 1
+              ? Array.from(
+                  { length: windingTargetOrderCount },
+                  (_, windingOrderIndex) =>
+                    [true, false].map((preferTargetDirectedLaneBias) => ({
+                      label: `expanded-winding-${windingOrderIndex}-${preferTargetDirectedLaneBias}`,
+                      useViaInPad: false,
+                      getViaHandedness: () => 0 as const,
+                      getViaPoint: (connection: PreparedConnection) =>
+                        coordinatedViaPoints.get(connection.connectionIndex)!,
+                      maximumRouteOrderAttempts: 1,
+                      windingOrderIndex,
+                      preferTargetDirectedLaneBias,
+                      reserveTerminalExitPoints: !preferTargetDirectedLaneBias,
+                      allowLayerInterleaving: true,
+                    })),
+                ).flat()
+              : []),
           ]
         : []
     const planeTerminationsAlreadyOccupyTheFanout = acceptedPlans.some(
@@ -2880,6 +3061,23 @@ export function* routeBusAlternativesSteps(
         }
       }
     }
+    if (alignWindingGridToPads && cornerSide) {
+      const layerLocalExitOffset = getCornerLaneOffsets(
+        bus,
+        acceptedPlans.filter((plan) => plan.targetLayer === targetLayer),
+      ).exit
+      if (layerLocalExitOffset !== cornerLaneOffsets.exit) {
+        // Preserve successful shared-band routes first. If those patterns
+        // fail, reuse the corner slots occupied only on other copper layers.
+        terminalPatterns.push(
+          ...terminalPatterns.map((pattern) => ({
+            ...pattern,
+            label: `${pattern.label}-layer-local-corner`,
+            cornerExitLaneOffset: layerLocalExitOffset,
+          })),
+        )
+      }
+    }
     const seenTerminalSignatures = new Set<string>()
     for (const terminalPattern of terminalPatterns) {
       const terminals = bus.connections.map((preparedConnection) => {
@@ -2889,7 +3087,8 @@ export function* routeBusAlternativesSteps(
           ? getCornerTargetTrack({
               bus,
               connection: preparedConnection,
-              cornerExitLaneOffset: cornerLaneOffsets.exit,
+              cornerExitLaneOffset:
+                terminalPattern.cornerExitLaneOffset ?? cornerLaneOffsets.exit,
               traceWidth,
               viaDiameter,
               clearance,
@@ -2899,9 +3098,15 @@ export function* routeBusAlternativesSteps(
               cornerBandTargetTrackOffset,
             })
           : getBoundaryTargetTrack({
+              allowLayerInterleaving: terminalPattern.allowLayerInterleaving,
               bus,
               connection: preparedConnection,
               boundaryDirection,
+              traceWidth,
+              clearance,
+              layerNames,
+              targetLayer,
+              windingOrderIndex: terminalPattern.windingOrderIndex,
             })
         return {
           connection: preparedConnection,
@@ -2981,7 +3186,7 @@ export function* routeBusAlternativesSteps(
         )
         .join(
           "|",
-        )}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}:${gridStepDivisor}:${alignGridToPads}:${Boolean(terminalPattern.localDogboneRepair)}`
+        )}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}:${gridStepDivisor}:${alignGridToPads}:${Boolean(terminalPattern.localDogboneRepair)}:${Boolean(terminalPattern.preferTargetDirectedLaneBias)}:${Boolean(terminalPattern.reserveTerminalExitPoints)}`
       if (seenTerminalSignatures.has(terminalSignature)) continue
       seenTerminalSignatures.add(terminalSignature)
       const windingSteps = routeViaMinimalWindingAlternativesSteps(
@@ -3003,6 +3208,8 @@ export function* routeBusAlternativesSteps(
           alignGridToPads,
           includeReverseTargetRotation: terminalPattern.localDogboneRepair,
           reservedVias,
+          softReservedVias,
+          reserveTerminalExitPoints: terminalPattern.reserveTerminalExitPoints,
           gridStepDivisor,
           preferTargetDirectedLaneBias:
             terminalPattern.preferTargetDirectedLaneBias,
@@ -3095,6 +3302,10 @@ export function* routeBusAlternativesSteps(
             bus,
             connection: preparedConnection,
             boundaryDirection,
+            traceWidth,
+            clearance,
+            layerNames,
+            targetLayer,
           }),
     )
     const finalExitPoints = finalTracks.map((track) =>
@@ -3182,47 +3393,64 @@ export function* routeBusAlternativesSteps(
             ),
           )
         : []
-    const singletonMatchedVia =
-      bus.connections.length === 1
-        ? fixedViaPointsByConnectionIndex.get(
-            bus.connections[0]!.connectionIndex,
-          )
-        : undefined
-    const packageEdgeViaCandidates = singletonMatchedVia
-      ? [
-          {
-            distance: sourceCenter.x - bus.componentBounds.minX,
-            point: {
-              x: bus.componentBounds.minX - 2 * insetStep,
-              y: singletonMatchedVia.y,
-            },
-          },
-          {
-            distance: bus.componentBounds.maxX - sourceCenter.x,
-            point: {
-              x: bus.componentBounds.maxX + 2 * insetStep,
-              y: singletonMatchedVia.y,
-            },
-          },
-          {
-            distance: sourceCenter.y - bus.componentBounds.minY,
-            point: {
-              x: singletonMatchedVia.x,
-              y: bus.componentBounds.minY - 2 * insetStep,
-            },
-          },
-          {
-            distance: bus.componentBounds.maxY - sourceCenter.y,
-            point: {
-              x: singletonMatchedVia.x,
-              y: bus.componentBounds.maxY + 2 * insetStep,
-            },
-          },
-        ]
-          .toSorted((first, second) => first.distance - second.distance)
-          .map(({ point }) => [point])
-      : []
+    const matchedVias = bus.connections.map(
+      (connection) =>
+        fixedViaPointsByConnectionIndex.get(connection.connectionIndex)!,
+    )
+    const packageEdgeViaCandidates = [
+      {
+        distance: sourceCenter.x - bus.componentBounds.minX,
+        axis: "x" as const,
+        value: bus.componentBounds.minX - 2 * insetStep,
+      },
+      {
+        distance: bus.componentBounds.maxX - sourceCenter.x,
+        axis: "x" as const,
+        value: bus.componentBounds.maxX + 2 * insetStep,
+      },
+      {
+        distance: sourceCenter.y - bus.componentBounds.minY,
+        axis: "y" as const,
+        value: bus.componentBounds.minY - 2 * insetStep,
+      },
+      {
+        distance: bus.componentBounds.maxY - sourceCenter.y,
+        axis: "y" as const,
+        value: bus.componentBounds.maxY + 2 * insetStep,
+      },
+    ]
+      .toSorted((a, b) => a.distance - b.distance)
+      .flatMap(({ axis, value }) => {
+        const otherAxis = axis === "x" ? "y" : "x"
+        const mean =
+          matchedVias.reduce((sum, via) => sum + via[otherAxis], 0) /
+          matchedVias.length
+        const order = matchedVias
+          .map((via, index) => ({ index, track: via[otherAxis] }))
+          .toSorted((a, b) => a.track - b.track || a.index - b.index)
+        const pitch = viaDiameter + clearance
+        const points = matchedVias.map((via, index) => ({
+          ...via,
+          [axis]: value,
+          [otherAxis]:
+            order.length === 2 &&
+            Math.abs(order[1]!.track - order[0]!.track) < pitch
+              ? mean + (order.findIndex((v) => v.index === index) - 0.5) * pitch
+              : via[otherAxis],
+        }))
+        return points.length === 2
+          ? [points, [points[1]!, points[0]!]]
+          : [points]
+      })
+    const preferPackageEdgeVias =
+      bus.connections.length === 2 && Boolean(getCornerSide(bus))
     const viaCandidates = [
+      ...(preferPackageEdgeVias ? packageEdgeViaCandidates : []).map(
+        (points) => ({
+          points,
+          boundarySide: false,
+        }),
+      ),
       ...displacedViaCandidates.map((points) => ({
         points,
         boundarySide: false,
@@ -3231,13 +3459,15 @@ export function* routeBusAlternativesSteps(
         points,
         boundarySide: true,
       })),
-      // Preserve existing singleton escapes before trying a short source-layer
-      // route beyond the package. The target layer can then wind to the exit
+      // Preserve existing centered and singleton escapes before trying a short
+      // source-layer route beyond the package. The target layer can then wind to the exit
       // without a local via being fenced in by an already-routed wide bus.
-      ...packageEdgeViaCandidates.map((points) => ({
-        points,
-        boundarySide: false,
-      })),
+      ...(!preferPackageEdgeVias ? packageEdgeViaCandidates : []).map(
+        (points) => ({
+          points,
+          boundarySide: false,
+        }),
+      ),
     ]
     for (const { points: boundaryViaPoints, boundarySide } of viaCandidates) {
       const boundaryVias = bus.connections.map((connection, index) => ({
@@ -3301,6 +3531,7 @@ export function* routeBusAlternativesSteps(
           allowBlindAndBuriedVias,
           allowSameNetMerges,
           maximumRouteOrderAttempts: bus.connections.length === 1 ? 3 : 6,
+          softReservedVias,
           reservedVias:
             bus.connections.length > 1
               ? [...reservedVias, ...boundaryVias]
@@ -3350,6 +3581,7 @@ export function* routeBusAlternativesSteps(
             allowSameNetMerges,
             maximumRouteOrderAttempts: 6,
             reservedVias,
+            softReservedVias,
             gridStepDivisor: 2,
             alignGridToPads: true,
           },

package/lib/route-via-minimal-winding.ts

@@ -62,6 +62,8 @@ export interface RouteViaMinimalWindingParams {
   allowSameNetMerges?: boolean
   maximumRouteOrderAttempts?: number
   reservedVias?: readonly ViaMinimalWindingReservedVia[]
+  /** Cost hints for provisional sites that the caller must rematch before commit. */
+  softReservedVias?: readonly ViaMinimalWindingReservedVia[]
   /** Use a finer uniform grid for narrow channels between reserved vias. */
   gridStepDivisor?: 1 | 2
   /** Bias bounded fixed-site searches toward the remote target band. */
@@ -74,6 +76,8 @@ export interface RouteViaMinimalWindingParams {
   alignGridToPads?: boolean
   /** Defer the outermost reversed target while routing the inner terminals. */
   includeReverseTargetRotation?: boolean
+  /** Keep earlier lanes clear of every remaining terminal exit. */
+  reserveTerminalExitPoints?: boolean
 }
 
 export interface RouteViaMinimalWindingProgress {
@@ -637,12 +641,14 @@ export function* routeViaMinimalWindingAlternativesSteps(
     allowSameNetMerges = false,
     maximumRouteOrderAttempts,
     reservedVias = [],
+    softReservedVias = [],
     gridStepDivisor = 1,
     preferTargetDirectedLaneBias = false,
     allowSourceLayerRouting = false,
     adaptiveRouteOrder = false,
     alignGridToPads = false,
     includeReverseTargetRotation = false,
+    reserveTerminalExitPoints = false,
   } = params
   if (
     maximumRouteOrderAttempts !== undefined &&
@@ -702,6 +708,40 @@ export function* routeViaMinimalWindingAlternativesSteps(
       point: { x: gridMinX + column * gridStep, y: gridMinY + row * gridStep },
     }
   })
+  // Provisional plane barrels guide search without being fixed obstacles.
+  // Touch only the small grid rectangles around each disk, not every node.
+  const softViaCosts = softReservedVias.length
+    ? new Float32Array(nodeCount)
+    : undefined
+  if (softViaCosts) {
+    for (const { via } of softReservedVias) {
+      if (!via.spanLayers.includes(targetLayer)) continue
+      const radius = via.diameter / 2 + traceWidth / 2 + clearance
+      const minimumColumn = Math.max(
+        0,
+        Math.ceil((via.center.x - radius - gridMinX) / gridStep),
+      )
+      const maximumColumn = Math.min(
+        columnCount - 1,
+        Math.floor((via.center.x + radius - gridMinX) / gridStep),
+      )
+      const minimumRow = Math.max(
+        0,
+        Math.ceil((via.center.y - radius - gridMinY) / gridStep),
+      )
+      const maximumRow = Math.min(
+        rowCount - 1,
+        Math.floor((via.center.y + radius - gridMinY) / gridStep),
+      )
+      for (let row = minimumRow; row <= maximumRow; row++) {
+        for (let column = minimumColumn; column <= maximumColumn; column++) {
+          const index = row * columnCount + column
+          if (distance(nodes[index]!.point, via.center) < radius)
+            softViaCosts[index] = softViaCosts[index]! + 25 * gridStep
+        }
+      }
+    }
+  }
   const sampledGridPoints = includeVisualization
     ? nodes
         .filter(
@@ -869,6 +909,14 @@ export function* routeViaMinimalWindingAlternativesSteps(
         return false
       }
     }
+    for (const other of reserveTerminalExitPoints ? terminals : []) {
+      if (sharesNet(connectionName, other.connection.connection.name)) continue
+      if (
+        distancePointToSegment(other.exitPoint, segment.start, segment.end) <
+        traceWidth + clearance - EPSILON
+      )
+        return false
+    }
     const segmentMinX = Math.min(segment.start.x, segment.end.x)
     const segmentMaxX = Math.max(segment.start.x, segment.end.x)
     const segmentMinY = Math.min(segment.start.y, segment.end.y)
@@ -1247,7 +1295,8 @@ export function* routeViaMinimalWindingAlternativesSteps(
             ? gridStep * Math.SQRT2
             : gridStep) +
           (addsTurn ? gridStep * 0.2 : 0) +
-          lanePenalty
+          lanePenalty +
+          (softViaCosts?.[nextNode] ?? 0)
         const nextState = nextNode * 9 + directionIndex
         if (nextDistance >= distances[nextState]! - EPSILON) continue
         const edgeIndex = current.node * 8 + directionIndex

package/package.json

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