@tscircuit/fanout-solver 0.0.59 → 0.0.60

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,
@@ -1982,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
@@ -2164,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 }
@@ -2311,6 +2447,7 @@ export class FanoutSolver extends BaseSolver {
           useConfiguredDensePlaneRouting &&
           singleLayerBus !== bus &&
           !embeddedNarrowBusAlreadyRouted
+        let usedSoftPlaneRepair = false
         let busPlans = (yield* routeAlternatives(
           preferSingleLayerWinding
             ? { ...routeParams, bus: singleLayerBus }
@@ -2417,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)
@@ -2430,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)

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,
@@ -3095,6 +3216,10 @@ export function* routeBusAlternativesSteps(
             bus,
             connection: preparedConnection,
             boundaryDirection,
+            traceWidth,
+            clearance,
+            layerNames,
+            targetLayer,
           }),
     )
     const finalExitPoints = finalTracks.map((track) =>
@@ -3182,47 +3307,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 +3373,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 +3445,7 @@ export function* routeBusAlternativesSteps(
           allowBlindAndBuriedVias,
           allowSameNetMerges,
           maximumRouteOrderAttempts: bus.connections.length === 1 ? 3 : 6,
+          softReservedVias,
           reservedVias:
             bus.connections.length > 1
               ? [...reservedVias, ...boundaryVias]
@@ -3350,6 +3495,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. */
@@ -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.59",
+  "version": "0.0.60",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",