@tscircuit/fanout-solver 0.0.58 → 0.0.60

package/README.md

@@ -330,6 +330,11 @@ the solver commit, dataset revision, configuration, solve totals, every sample's
 status and timing, and partial routing/validation counts. Reports are saved after
 every completed sample, including the total selected count to identify incomplete runs.
 Timed-out workers do not retain their in-flight routing counts.
+Every solved case also writes `benchmark-results/<sample-id>.svg`. These SVGs
+are committed so route changes can be reviewed in Git. A run replaces the selected
+cases' snapshots and removes their stale SVGs if they no longer solve; filtered
+runs preserve unselected snapshots. JSON reports and captured inputs remain
+ignored. CI includes the SVGs in its benchmark artifacts.
 Compare reports with the same budgets to track progress. Solved means validated
 AM62L fanout, not RAM fanout or downstream inter-chip routing. Partial, error,
 and timeout rows are benchmark results (exit 0); invalid CLI arguments or report

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,
@@ -1397,9 +1401,14 @@ export class FanoutSolver extends BaseSolver {
     denseRoutingStrategy?: "pad-aligned" | "boundary-aligned"
     lengthMatchingStage?: "before-planes" | "after-planes"
     promotedPlaneReservationBusIds?: readonly string[]
+    preferredBoundaryViaPoints?: ReadonlyMap<number, { x: number; y: number }>
     planeReservationRetryCount?: number
   }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
     if (this.config.allowBlindAndBuriedVias) return null
+    // An outside-package singleton escape can depend on the completed signal
+    // field. Keep those sites as preferences when plane reservations change;
+    // actual conflicts may still move.
+    let boundaryViaPointsForRetry = params.preferredBoundaryViaPoints
     const usePadAlignedDenseRouting =
       params.denseRoutingStrategy !== "boundary-aligned"
     const debugDense = (...values: unknown[]) => {
@@ -1444,9 +1453,12 @@ export class FanoutSolver extends BaseSolver {
       )
     const useConfiguredDensePlaneRouting =
       configuredDensePlaneRouting || useAdaptiveDensePlaneRouting
+    // A completed boundary assignment remains worth repairing jointly after
+    // plane reservations change; a greedy refill can discard that assignment.
     const useAdaptiveJointPlaneSelection =
       useAdaptiveDensePlaneRouting &&
-      (params.planeReservationRetryCount ?? 0) === 0
+      ((params.planeReservationRetryCount ?? 0) === 0 ||
+        Boolean(params.preferredBoundaryViaPoints))
     const matchLengthsAfterPlanes =
       useConfiguredDensePlaneRouting &&
       params.lengthMatchingStage !== "before-planes"
@@ -1871,19 +1883,45 @@ export class FanoutSolver extends BaseSolver {
             )
           })
         : []
+    // A corner singleton on the outward source row must leave before its
+    // surrounding wide bus closes the shared target-layer corridor.
     const throughAllLeadingSingletonBuses = hasThreeWideBoundaryBuses
       ? singletonBoundaryBuses.filter((singletonBus) => {
           const containingWideBus = getContainingWideSourceField(singletonBus)
           const singletonTargetLayer =
             params.busLayerAssignments[singletonBus.busId]
+          if (!containingWideBus || !singletonTargetLayer) return false
           const containingWideLayers =
-            containingWideBus?.routableEscapeLayers ??
-            containingWideBus?.allowedLayers ??
+            containingWideBus.routableEscapeLayers ??
+            containingWideBus.allowedLayers ??
             []
+          const sourceAxis =
+            singletonBus.exitEdge === "left" ||
+            singletonBus.exitEdge === "right"
+              ? "x"
+              : "y"
+          const wideCoordinates = containingWideBus.connections.map(
+            (connection) => connection.sourcePoint[sourceAxis],
+          )
+          const outwardSourceCoordinate =
+            singletonBus.exitEdge === "left" ||
+            singletonBus.exitEdge === "bottom"
+              ? Math.min(...wideCoordinates)
+              : Math.max(...wideCoordinates)
+          const isOnOutwardSourceEdge = singletonBus.connections.every(
+            (connection) =>
+              Math.abs(
+                connection.sourcePoint[sourceAxis] - outwardSourceCoordinate,
+              ) < 1e-9,
+          )
           return Boolean(
-            containingWideBus &&
-              singletonTargetLayer &&
-              !containingWideLayers.includes(singletonTargetLayer),
+            !containingWideLayers.includes(singletonTargetLayer) ||
+              (useAdaptiveDensePlaneRouting &&
+                isOnOutwardSourceEdge &&
+                getCornerBandSide(
+                  singletonBus.exitEdge,
+                  singletonBus.preferredExit,
+                )),
           )
         })
       : []
@@ -1948,14 +1986,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
@@ -1994,6 +2053,8 @@ export class FanoutSolver extends BaseSolver {
             traceWidth: this.config.traceWidth,
             clearance: this.config.clearance,
             maximumSearchStates: 100_000,
+            preferredViaPointsByConnectionIndex:
+              params.preferredBoundaryViaPoints,
             preferredBoundaryPerpendicularSideByBusId,
             preferBoundaryOutwardByBusId,
             additionalObstacles: denseAdditionalObstacles,
@@ -2012,6 +2073,8 @@ export class FanoutSolver extends BaseSolver {
           traceWidth: this.config.traceWidth,
           clearance: this.config.clearance,
           maximumSearchStates: 20_000,
+          preferredViaPointsByConnectionIndex:
+            params.preferredBoundaryViaPoints,
           preferredBoundaryPerpendicularSideByBusId,
           preferBoundaryOutwardByBusId,
           additionalObstacles: denseAdditionalObstacles,
@@ -2070,6 +2133,8 @@ export class FanoutSolver extends BaseSolver {
             traceWidth: this.config.traceWidth,
             clearance: this.config.clearance,
             maximumSearchStates: 100_000,
+            preferredViaPointsByConnectionIndex:
+              params.preferredBoundaryViaPoints,
             preferredBoundaryPerpendicularSideByBusId,
             preferBoundaryOutwardByBusId,
             fixedViaPointsByConnectionIndex: seedViaPoints,
@@ -2124,6 +2189,117 @@ export class FanoutSolver extends BaseSolver {
             bus,
           ]),
       ]
+      const areAdjacentInvertedNarrowBuses = (
+        first: PreparedBus,
+        second: PreparedBus,
+      ): boolean => {
+        if (
+          !usePadAlignedDenseRouting ||
+          useConfiguredDensePlaneRouting ||
+          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 multiLayerLeadingSingletonBuses) {
+        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)
+          }
+        }
+      }
       let fixedViaPointsByConnectionIndex: ReadonlyMap<
         number,
         { x: number; y: number }
@@ -2221,8 +2397,10 @@ export class FanoutSolver extends BaseSolver {
           allowBoundarySideViaFallback: bus.connections.length === 1,
           preferCornerBoundaryVia: useConfiguredDensePlaneRouting,
           adaptiveWindingRouteOrder,
+          // Retain pad-aligned channels even when plane sites are reserved
+          // adaptively; the boundary grid can fence off a turning wide bus.
           alignWindingGridToPads:
-            usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting,
+            usePadAlignedDenseRouting && !configuredDensePlaneRouting,
           fixedViaFallbackRouteOrderAttempts: adaptiveWindingRouteOrder
             ? 60
             : useConfiguredDensePlaneRouting
@@ -2269,6 +2447,7 @@ export class FanoutSolver extends BaseSolver {
           useConfiguredDensePlaneRouting &&
           singleLayerBus !== bus &&
           !embeddedNarrowBusAlreadyRouted
+        let usedSoftPlaneRepair = false
         let busPlans = (yield* routeAlternatives(
           preferSingleLayerWinding
             ? { ...routeParams, bus: singleLayerBus }
@@ -2375,6 +2554,86 @@ export class FanoutSolver extends BaseSolver {
             }
           }
         }
+        // Once wide-bus copper constrains the field, retry a blocked wide bus
+        // with provisional plane sites as search costs. Future boundary sites
+        // remain fixed, and a complete joint rematch must validate the repair.
+        if (
+          !busPlans &&
+          bus.connections.length >= 8 &&
+          boundaryBuses.some(
+            (candidate) =>
+              candidate.connections.length >= 8 &&
+              matchedPlans.some((plan) => plan.busId === candidate.busId),
+          )
+        ) {
+          const committedNames = new Set(
+            matchedPlans.map((plan) => plan.connectionName),
+          )
+          const futurePlaneNames = new Set(
+            this.preparedBuses
+              .filter((candidate) => candidate.termination.type === "plane")
+              .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) => !futurePlaneNames.has(reserved.connectionName),
+              ),
+              softReservedVias: routeParams.reservedVias.filter((reserved) =>
+                futurePlaneNames.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
+              usedSoftPlaneRepair = true
+            }
+          }
+        }
         if (busPlans && bus.maxLengthSkew !== undefined) {
           const lengths = busPlans.map((plan) => plan.length)
           const rawSkew = Math.max(...lengths) - Math.min(...lengths)
@@ -2388,7 +2647,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 the jointly rematched repair: routeParams still carries the
+          // earlier provisional sites and cannot safely replace its geometry.
+          if (
+            needsRouteDiversity &&
+            !matchLengthsAfterPlanes &&
+            !usedSoftPlaneRepair
+          ) {
             busPlans = (yield* routeAlternatives(routeParams, 3)).toSorted(
               (first, second) => {
                 const firstLengths = first.map((plan) => plan.length)
@@ -2407,6 +2672,31 @@ export class FanoutSolver extends BaseSolver {
           return false
         }
         matchedPlans.push(...busPlans)
+        if (
+          matchedPlans.length ===
+            boundaryBuses.reduce(
+              (sum, candidate) => sum + candidate.connections.length,
+              0,
+            ) &&
+          matchedPlans.some((plan) => {
+            const bus = boundaryBuses.find(
+              (candidate) => candidate.busId === plan.busId,
+            )
+            if (bus?.connections.length !== 1 || !plan.via) return false
+            const { center } = plan.via
+            return (
+              center.x < bus.componentBounds.minX ||
+              center.x > bus.componentBounds.maxX ||
+              center.y < bus.componentBounds.minY ||
+              center.y > bus.componentBounds.maxY
+            )
+          })
+        )
+          boundaryViaPointsForRetry = new Map(
+            matchedPlans
+              .filter((plan) => plan.via)
+              .map((plan) => [plan.connectionIndex, plan.via!.center]),
+          )
         debugDense("route:complete", bus.busId, busPlans.length)
         return true
       }.bind(this)
@@ -2932,7 +3222,14 @@ export class FanoutSolver extends BaseSolver {
               let alternatePlaneSearchStates = 0
               const maximumAlternatePlaneSearchStates = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_SEARCH_STATES ??
-                  (useConfiguredDensePlaneRouting ? 3_000_000 : 1_000),
+                  // Keep the initial search short before reserving blocked
+                  // plane sites. Later joint repairs retain the full budget.
+                  (useAdaptiveDensePlaneRouting &&
+                  (params.planeReservationRetryCount ?? 0) === 0
+                    ? 10_000
+                    : useConfiguredDensePlaneRouting
+                      ? 3_000_000
+                      : 1_000),
               )
               const maximumAlternatePlaneRoutes = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_ROUTE_COUNT ??
@@ -3838,6 +4135,7 @@ export class FanoutSolver extends BaseSolver {
           allowSameNetMerges: this.config.allowSameNetMerges,
           allowMatchingInsideDenseBounds: true,
           allowPairLaneSpreading: true,
+          allowUnconstrainedLaneRerouting: true,
         }
         let matchedLengthResult = matchBusPlanLengths(lengthMatchingParams)
         const shortenedBusIds = new Set<string>()
@@ -3927,6 +4225,7 @@ export class FanoutSolver extends BaseSolver {
         debugDense("promote-reservations", refinedPromotions)
         return yield* this.routeDenseThroughAllMixedTerminationSteps({
           ...params,
+          preferredBoundaryViaPoints: boundaryViaPointsForRetry,
           promotedPlaneReservationBusIds: [
             ...(params.promotedPlaneReservationBusIds ?? []),
             ...refinedPromotions,

package/lib/match-bus-lengths.ts

@@ -8,7 +8,9 @@ import {
   distanceSegmentToSegment,
   segmentsAreClear,
 } from "./geometry"
-import { fanoutPlansAreClear } from "./route-bus"
+import { getCopperLayerNames } from "./layer-names"
+import { fanoutPlansAreClear, fanoutPlansAreMutuallyClear } from "./route-bus"
+import { routeViaMinimalWinding } from "./route-via-minimal-winding"
 import type {
   Bounds,
   FanoutRoutePlan,
@@ -647,6 +649,8 @@ export function matchBusPlanLengths(params: {
   allowMatchingInsideDenseBounds?: boolean
   /** Allow a differential pair's longer lane to move aside before tuning its mate. */
   allowPairLaneSpreading?: boolean
+  /** Allow one unconstrained boundary lane to move around a tuning meander. */
+  allowUnconstrainedLaneRerouting?: boolean
   /**
    * Rejects a geometrically clear candidate when it would make a caller-owned
    * downstream assignment (such as pending plane dogbones) infeasible.
@@ -866,6 +870,124 @@ export function matchBusPlanLengths(params: {
           if (++attempts >= 4) break
         }
       }
+      if (!acceptedPlans && params.allowUnconstrainedLaneRerouting) {
+        // A neighboring singleton may occupy the only tuning window. Keep its
+        // source dogbone, via and boundary endpoint fixed, and reroute only its
+        // target-layer copper around a complete meander. Constrained buses and
+        // plane routes are never displaced by this bounded repair.
+        let rerouteAttempts = 0
+        candidateSearch: for (const targetAddedLength of targetAddedLengths) {
+          const candidates = createTunedPlanCandidates({
+            plan: shortest,
+            bus,
+            targetAddedLength,
+            clearance,
+            sharedBoundary: bus.sharedBoundary,
+            allowInsideDenseBounds: allowMatchingInsideDenseBounds,
+          })
+          for (const candidate of candidates) {
+            if (
+              !fanoutPlansAreClear({
+                plans: [candidate],
+                srj: inputSrj,
+                sharedBoundary,
+                clearance,
+                allowBlindAndBuriedVias,
+                allowSameNetMerges,
+              })
+            )
+              continue
+            const blockers = matchedPlans.filter(
+              (plan) =>
+                plan !== shortest &&
+                !fanoutPlansAreMutuallyClear({
+                  plans: [candidate, plan],
+                  srj: inputSrj,
+                  clearance,
+                  allowSameNetMerges,
+                }),
+            )
+            if (blockers.length !== 1) continue
+            const blocker = blockers[0]!
+            const blockerBus = preparedBuses.find(
+              (prepared) => prepared.busId === blocker.busId,
+            )
+            if (
+              !blockerBus ||
+              blockerBus.termination.type !== "boundary" ||
+              blockerBus.maxLengthSkew !== undefined ||
+              blockerBus.connections.length !== 1 ||
+              !blocker.via ||
+              blocker.additionalVias?.length ||
+              blocker.planeEndpointVia ||
+              blocker.segments.filter(
+                (segment) => segment.layer === blocker.sourceLayer,
+              ).length !== 1
+            )
+              continue
+            const nextPlans = matchedPlans.map((plan) =>
+              plan === shortest ? candidate : plan,
+            )
+            for (const alignGridToPads of [true, false]) {
+              if (rerouteAttempts++ >= 4) break candidateSearch
+              const rerouted = routeViaMinimalWinding({
+                srj: inputSrj,
+                bus: blockerBus,
+                terminals: [
+                  {
+                    connection: blockerBus.connections[0]!,
+                    viaPoint: blocker.via.center,
+                    exitPoint: blocker.exitPoint,
+                  },
+                ],
+                targetLayer: blocker.targetLayer,
+                acceptedPlans: nextPlans.filter((plan) => plan !== blocker),
+                layerNames: getCopperLayerNames(inputSrj.layerCount),
+                traceWidth: blocker.segments[0]!.width,
+                viaDiameter: blocker.via.diameter,
+                viaHoleDiameter: blocker.via.holeDiameter,
+                clearance,
+                allowBlindAndBuriedVias,
+                allowSameNetMerges,
+                gridStepDivisor: 2,
+                alignGridToPads,
+                maximumRouteOrderAttempts: 1,
+                preferTargetDirectedLaneBias: true,
+              })?.[0]
+              if (!rerouted) continue
+              // Rebuild from the original plan to preserve its route identity,
+              // endpoint metadata and physical via span exactly.
+              const repaired = createPlanWithSegments(blocker, [
+                blocker.segments[0]!,
+                ...rerouted.segments.slice(1),
+              ])
+              if (!repaired) continue
+              const repairedPlans = nextPlans.map((plan) =>
+                plan === blocker ? repaired : plan,
+              )
+              if (
+                getBusSkew(
+                  repairedPlans.filter((plan) => plan.busId === bus.busId),
+                ) >
+                  maxLengthSkew + EPSILON ||
+                !fanoutPlansAreClear({
+                  plans: repairedPlans,
+                  srj: inputSrj,
+                  sharedBoundary,
+                  clearance,
+                  allowBlindAndBuriedVias,
+                  allowSameNetMerges,
+                }) ||
+                (candidatePlansAreFeasible &&
+                  !candidatePlansAreFeasible(repairedPlans))
+              )
+                continue
+              acceptedPlans = repairedPlans
+              break candidateSearch
+            }
+          }
+        }
+      }
       if (!acceptedPlans) return { plans: null, failedBus: bus }
       matchedPlans = acceptedPlans
     }

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
@@ -311,10 +313,89 @@ function getWindingCrossoverLayer(params: {
   )
 }
 
+function getDistributedBoundaryTargetTracks(params: {
+  bus: PreparedBus
+  boundaryDirection: FanoutDirection
+  traceWidth: number
+  clearance: number
+}): 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 (
+    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
 }): number {
   const requestedTrack = getPerpendicularAxis(
     params.connection.exitTargetPoint ?? params.connection.targetPoint,
@@ -326,6 +407,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 +1199,10 @@ function buildPlan(params: {
             bus,
             connection: preparedConnection,
             boundaryDirection,
+            traceWidth,
+            clearance,
+            layerNames,
+            targetLayer,
           })
         : track
   const connectionRank = getConnectionRank(bus, preparedConnection)
@@ -2459,6 +2560,7 @@ export function* routeBusAlternativesSteps(
     stopAfterFirstRejectedViaMinimalCandidate = false,
     fixedViaPointsByConnectionIndex,
     reservedVias = [],
+    softReservedVias = [],
     viaMinimalOnly = false,
     allowBoundarySideViaFallback = false,
     preferCornerBoundaryVia = false,
@@ -2608,14 +2710,21 @@ export function* routeBusAlternativesSteps(
       localDogboneRepair?: boolean
     }
     const maximumThroughAllRouteOrderAttempts = 24
-    const windingTargetOrderCount = cornerSide
-      ? getWindingTargetOrders({
-          bus,
-          boundaryDirection,
-          layerNames,
-          targetLayer,
-        }).orders.length
-      : 1
+    const windingTargetOrderCount =
+      cornerSide ||
+      getDistributedBoundaryTargetTracks({
+        bus,
+        boundaryDirection,
+        traceWidth,
+        clearance,
+      })
+        ? getWindingTargetOrders({
+            bus,
+            boundaryDirection,
+            layerNames,
+            targetLayer,
+          }).orders.length
+        : 1
     const uniformDogboneTerminalPatterns: CoordinatedTerminalPattern[] =
       viaHandednesses.map((viaHandedness) => ({
         label: `uniform-${viaHandedness}`,
@@ -2760,7 +2869,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,
@@ -2902,6 +3017,11 @@ export function* routeBusAlternativesSteps(
               bus,
               connection: preparedConnection,
               boundaryDirection,
+              traceWidth,
+              clearance,
+              layerNames,
+              targetLayer,
+              windingOrderIndex: terminalPattern.windingOrderIndex,
             })
         return {
           connection: preparedConnection,
@@ -3003,6 +3123,7 @@ export function* routeBusAlternativesSteps(
           alignGridToPads,
           includeReverseTargetRotation: terminalPattern.localDogboneRepair,
           reservedVias,
+          softReservedVias,
           gridStepDivisor,
           preferTargetDirectedLaneBias:
             terminalPattern.preferTargetDirectedLaneBias,
@@ -3060,9 +3181,9 @@ export function* routeBusAlternativesSteps(
   // A through-via does not have to sit next to the source pad. A narrow bus
   // embedded in another bus's source field can have every local dogbone site
   // occupied while still having a clear source-layer escape. A pair first
-  // relocates its two vias just outside the nearest package edge; a singleton
-  // retains the boundary-side-via fallback. Both forms preserve one via per
-  // signal without weakening any clearance rule.
+  // relocates its two vias just outside the nearest package edge. A singleton
+  // tries the existing boundary-side vias before searching outside the package.
+  // Both forms preserve one via per signal without weakening clearance rules.
   if (
     alternatives.length === 0 &&
     allowBoundarySideViaFallback &&
@@ -3095,6 +3216,10 @@ export function* routeBusAlternativesSteps(
             bus,
             connection: preparedConnection,
             boundaryDirection,
+            traceWidth,
+            clearance,
+            layerNames,
+            targetLayer,
           }),
     )
     const finalExitPoints = finalTracks.map((track) =>
@@ -3182,7 +3307,64 @@ export function* routeBusAlternativesSteps(
             ),
           )
         : []
+    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,
@@ -3191,6 +3373,15 @@ export function* routeBusAlternativesSteps(
         points,
         boundarySide: true,
       })),
+      // 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.
+      ...(!preferPackageEdgeVias ? packageEdgeViaCandidates : []).map(
+        (points) => ({
+          points,
+          boundarySide: false,
+        }),
+      ),
     ]
     for (const { points: boundaryViaPoints, boundarySide } of viaCandidates) {
       const boundaryVias = bus.connections.map((connection, index) => ({
@@ -3254,6 +3445,7 @@ export function* routeBusAlternativesSteps(
           allowBlindAndBuriedVias,
           allowSameNetMerges,
           maximumRouteOrderAttempts: bus.connections.length === 1 ? 3 : 6,
+          softReservedVias,
           reservedVias:
             bus.connections.length > 1
               ? [...reservedVias, ...boundaryVias]
@@ -3303,6 +3495,7 @@ export function* routeBusAlternativesSteps(
             allowSameNetMerges,
             maximumRouteOrderAttempts: 6,
             reservedVias,
+            softReservedVias,
             gridStepDivisor: 2,
             alignGridToPads: true,
           },
@@ -3355,7 +3548,9 @@ export function* routeBusAlternativesSteps(
           )
           return {
             ...sourceLayerPlan,
-            ...(preferCornerBoundaryVia || bus.connections.length > 1
+            ...(preferCornerBoundaryVia ||
+            bus.connections.length > 1 ||
+            !boundarySide
               ? { sourceEscapeSegmentCount: sourceLayerPlan.segments.length }
               : {}),
             targetLayer,

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. */
@@ -637,6 +639,7 @@ export function* routeViaMinimalWindingAlternativesSteps(
     allowSameNetMerges = false,
     maximumRouteOrderAttempts,
     reservedVias = [],
+    softReservedVias = [],
     gridStepDivisor = 1,
     preferTargetDirectedLaneBias = false,
     allowSourceLayerRouting = false,
@@ -702,6 +705,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(
@@ -1247,7 +1284,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.58",
+  "version": "0.0.60",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",