@tscircuit/fanout-solver 0.0.39 → 0.0.41

package/lib/fanout-solver.ts

@@ -14,7 +14,10 @@ import {
   getViaSpanLayers,
 } from "./layer-names"
 import { matchBusPlanLengths } from "./match-bus-lengths"
-import { matchComponentDogboneViaSites } from "./match-component-dogbone-via-sites"
+import {
+  getComponentDogboneViaSiteCandidates,
+  matchComponentDogboneViaSites,
+} from "./match-component-dogbone-via-sites"
 import { connectionsShareElectricalNet } from "./net-identity"
 import {
   prepareFanoutBuses,
@@ -514,10 +517,6 @@ export class FanoutSolver extends BaseSolver {
   private bestAttempt: AssignmentAttempt | null = null
   private lengthMatchingFailure: FanoutValidationIssue | null = null
   private endpointCompletion: CompleteOriginalEndpointsResult | null = null
-  private denseDogboneViaPoints:
-    | Map<number, { x: number; y: number }>
-    | null
-    | undefined
 
   constructor(
     public readonly inputSrj: SimpleRouteJson,
@@ -723,9 +722,60 @@ export class FanoutSolver extends BaseSolver {
   }): MixedTerminationState | null {
     if (this.config.allowBlindAndBuriedVias) return null
 
-    const boundaryBuses = params.busesInRoutingOrder.filter(
+    const unsortedBoundaryBuses = params.busesInRoutingOrder.filter(
       (bus) => bus.termination.type === "boundary",
     )
+    const useJointFourBusReservation =
+      unsortedBoundaryBuses.length === 4 &&
+      new Set(unsortedBoundaryBuses.map((bus) => bus.connections.length)).size >
+        1
+    const boundaryBuses = unsortedBoundaryBuses.toSorted((first, second) => {
+      // Reserve the dense escape field for the widest buses first. Small
+      // control groups can usually route around their copper, while routing
+      // a two-line corner bus first can consume a critical channel needed by
+      // an eight-line winding bus and force the expensive fallback search.
+      if (useJointFourBusReservation) {
+        const connectionCountDifference =
+          second.connections.length - first.connections.length
+        if (connectionCountDifference !== 0) return connectionCountDifference
+      }
+      const cornerBandDifference =
+        Number(
+          Boolean(getCornerBandSide(second.exitEdge, second.preferredExit)),
+        ) -
+        Number(Boolean(getCornerBandSide(first.exitEdge, first.preferredExit)))
+      if (cornerBandDifference !== 0) return cornerBandDifference
+      const firstIsCorner = Boolean(
+        getCornerBandSide(first.exitEdge, first.preferredExit),
+      )
+      if (!firstIsCorner) {
+        const getSourceSpan = (bus: PreparedBus): number => {
+          const xCoordinates = bus.connections.map(
+            (connection) => connection.sourcePoint.x,
+          )
+          const yCoordinates = bus.connections.map(
+            (connection) => connection.sourcePoint.y,
+          )
+          return (
+            Math.max(...xCoordinates) -
+            Math.min(...xCoordinates) +
+            Math.max(...yCoordinates) -
+            Math.min(...yCoordinates)
+          )
+        }
+        const sourceSpanDifference =
+          getSourceSpan(second) - getSourceSpan(first)
+        if (Math.abs(sourceSpanDifference) > 1e-9) {
+          return sourceSpanDifference
+        }
+      }
+      const firstLayer = params.busLayerAssignments[first.busId]
+      const secondLayer = params.busLayerAssignments[second.busId]
+      const layerDifference =
+        this.config.layerNames.indexOf(firstLayer ?? "") -
+        this.config.layerNames.indexOf(secondLayer ?? "")
+      return -layerDifference
+    })
     // Preserve the caller/input order for the dense singleton fill. The
     // general routing sort is useful for heterogeneous buses, but ordering a
     // regular BGA power field by obstacle depth creates artificial local
@@ -763,119 +813,372 @@ export class FanoutSolver extends BaseSolver {
         getExitEdgeForDirection(bus.direction) !== bus.exitEdge,
       ]),
     )
-    if (this.denseDogboneViaPoints === undefined) {
-      this.denseDogboneViaPoints = matchComponentDogboneViaSites(
-        this.preparedBuses,
-        {
+    const canShareCopper = (
+      firstConnectionIndex: number,
+      secondConnectionIndex: number,
+    ): boolean => {
+      if (!this.config.allowSameNetMerges) return false
+      const firstConnectionName =
+        connectionNameByIndex.get(firstConnectionIndex)
+      const secondConnectionName = connectionNameByIndex.get(
+        secondConnectionIndex,
+      )
+      return Boolean(
+        firstConnectionName &&
+          secondConnectionName &&
+          connectionsShareElectricalNet(
+            this.routingSrj,
+            firstConnectionName,
+            secondConnectionName,
+          ),
+      )
+    }
+    // Four boundary buses leave too little slack for incremental site
+    // allocation: a valid early trace can consume the last dogbone site of a
+    // later narrow bus. Reserve every physical barrel before routing copper.
+    // Plane sites remain provisional and are rematched around the completed
+    // boundary plans below.
+    const jointViaPoints = useJointFourBusReservation
+      ? matchComponentDogboneViaSites([...planeBuses, ...boundaryBuses], {
           viaDiameter: this.config.viaDiameter,
           viaHoleDiameter: this.config.viaHoleDiameter,
           traceWidth: this.config.traceWidth,
           clearance: this.config.clearance,
-          maximumSearchStates: 20_000,
+          maximumSearchStates: 100_000,
           preferredBoundaryPerpendicularSideByBusId,
           preferBoundaryOutwardByBusId,
-          canShareCopper: (firstConnectionIndex, secondConnectionIndex) => {
-            if (!this.config.allowSameNetMerges) return false
-            const firstConnectionName =
-              connectionNameByIndex.get(firstConnectionIndex)
-            const secondConnectionName = connectionNameByIndex.get(
-              secondConnectionIndex,
-            )
-            return Boolean(
-              firstConnectionName &&
-                secondConnectionName &&
-                connectionsShareElectricalNet(
-                  this.routingSrj,
-                  firstConnectionName,
-                  secondConnectionName,
-                ),
+          canShareCopper,
+        })
+      : null
+    const seedViaPoints =
+      jointViaPoints ??
+      matchComponentDogboneViaSites([...planeBuses, boundaryBuses[0]!], {
+        viaDiameter: this.config.viaDiameter,
+        viaHoleDiameter: this.config.viaHoleDiameter,
+        traceWidth: this.config.traceWidth,
+        clearance: this.config.clearance,
+        maximumSearchStates: 20_000,
+        preferredBoundaryPerpendicularSideByBusId,
+        preferBoundaryOutwardByBusId,
+        canShareCopper,
+      })
+    if (seedViaPoints) {
+      let fixedViaPointsByConnectionIndex: ReadonlyMap<
+        number,
+        { x: number; y: number }
+      > = seedViaPoints
+      let matchedPlans: FanoutRoutePlan[] = []
+      let matchedRoutingSucceeded = true
+      const getReservedVias = (bus: PreparedBus) => {
+        const currentConnectionNames = new Set(
+          bus.connections.map((connection) => connection.connection.name),
+        )
+        return this.preparedBuses.flatMap((preparedBus) => {
+          const targetLayer = params.busLayerAssignments[preparedBus.busId]
+          if (!targetLayer) return []
+          return preparedBus.connections.flatMap((connection) => {
+            if (currentConnectionNames.has(connection.connection.name))
+              return []
+            const center = fixedViaPointsByConnectionIndex.get(
+              connection.connectionIndex,
             )
-          },
-        },
-      )
-    }
-    const fixedViaPointsByConnectionIndex = this.denseDogboneViaPoints
-    if (fixedViaPointsByConnectionIndex) {
-      const reservedViasByComponentId = new Map<
-        string,
-        Array<{
-          connectionName: string
-          via: {
-            center: { x: number; y: number }
-            diameter: number
-            spanLayers: string[]
-          }
-        }>
-      >()
-      for (const bus of this.preparedBuses) {
-        const targetLayer = params.busLayerAssignments[bus.busId]
-        if (!targetLayer) continue
-        const componentReservedVias =
-          reservedViasByComponentId.get(bus.componentId) ?? []
-        for (const connection of bus.connections) {
-          const center = fixedViaPointsByConnectionIndex.get(
-            connection.connectionIndex,
-          )
-          if (!center) continue
-          componentReservedVias.push({
-            connectionName: connection.connection.name,
-            via: {
-              center,
-              diameter: this.config.viaDiameter,
-              spanLayers: getViaSpanLayers({
-                fromLayer: connection.sourceLayer,
-                toLayer: targetLayer,
-                layerNames: this.config.layerNames,
-                allowBlindAndBuriedVias: false,
-              }),
-            },
+            if (!center) return []
+            return [
+              {
+                connectionName: connection.connection.name,
+                via: {
+                  center,
+                  diameter: this.config.viaDiameter,
+                  spanLayers: getViaSpanLayers({
+                    fromLayer: connection.sourceLayer,
+                    toLayer: targetLayer,
+                    layerNames: this.config.layerNames,
+                    allowBlindAndBuriedVias: false,
+                  }),
+                },
+              },
+            ]
           })
-        }
-        reservedViasByComponentId.set(bus.componentId, componentReservedVias)
+        })
       }
-
-      const matchedPlans: FanoutRoutePlan[] = []
-      let matchedRoutingSucceeded = true
-      for (const bus of boundaryBuses) {
+      const routeMatchedBoundaryBus = (bus: PreparedBus): boolean => {
         const targetLayer = params.busLayerAssignments[bus.busId]
         if (!targetLayer) {
+          return false
+        }
+        const routeParams = {
+          srj: this.routingSrj,
+          bus,
+          targetLayer,
+          acceptedPlans: matchedPlans,
+          layerNames: this.config.layerNames,
+          traceWidth: this.config.traceWidth,
+          viaDiameter: this.config.viaDiameter,
+          viaHoleDiameter: this.config.viaHoleDiameter,
+          clearance: this.config.clearance,
+          compactBusTracks: this.config.compactBusTracks,
+          allowBlindAndBuriedVias: false,
+          allowSameNetMerges: this.config.allowSameNetMerges,
+          staticClearanceCache: this.routeStaticClearanceCache,
+          fixedViaPointsByConnectionIndex,
+          reservedVias: getReservedVias(bus),
+          viaMinimalOnly: true,
+        } as const
+        let busPlans = routeBusAlternatives(routeParams, 1)[0]
+        if (busPlans && bus.maxLengthSkew !== undefined) {
+          const lengths = busPlans.map((plan) => plan.length)
+          const rawSkew = Math.max(...lengths) - Math.min(...lengths)
+          const needsRouteDiversity =
+            rawSkew - bus.maxLengthSkew > Math.max(1, bus.maxLengthSkew * 0.25)
+          // Only pay for additional A* variants when the first topology is so
+          // skewed that compact meanders are unlikely to absorb the deficit.
+          // This keeps already-near-matched buses on the single-attempt path.
+          if (needsRouteDiversity) {
+            busPlans = routeBusAlternatives(routeParams, 3).toSorted(
+              (first, second) => {
+                const firstLengths = first.map((plan) => plan.length)
+                const secondLengths = second.map((plan) => plan.length)
+                return (
+                  Math.max(...firstLengths) -
+                  Math.min(...firstLengths) -
+                  (Math.max(...secondLengths) - Math.min(...secondLengths))
+                )
+              },
+            )[0]
+          }
+        }
+        if (!busPlans) {
+          return false
+        }
+        matchedPlans.push(...busPlans)
+        return true
+      }
+
+      const firstBoundaryBus = boundaryBuses[0]!
+      const routedBoundaryBuses: PreparedBus[] = []
+      if (routeMatchedBoundaryBus(firstBoundaryBus)) {
+        routedBoundaryBuses.push(firstBoundaryBus)
+      } else {
+        matchedRoutingSucceeded = false
+      }
+      const remainingBoundaryBuses = boundaryBuses.slice(1)
+      while (matchedRoutingSucceeded && remainingBoundaryBuses.length > 0) {
+        const blockingSegments = matchedPlans.flatMap((plan) =>
+          plan.segments.map((segment) => ({
+            connectionIndex: plan.connectionIndex,
+            segment,
+          })),
+        )
+        let selectedBusIndex = -1
+        for (
+          let candidateIndex = 0;
+          candidateIndex < remainingBoundaryBuses.length;
+          candidateIndex++
+        ) {
+          const candidateBus = remainingBoundaryBuses[candidateIndex]!
+          const extendedViaPoints = jointViaPoints
+            ? // The joint map is deliberately kept intact so getReservedVias()
+              // blocks every future through-barrel during A*. Plane dogbones are
+              // validated/rematched once the boundary copper is complete.
+              new Map(fixedViaPointsByConnectionIndex)
+            : matchComponentDogboneViaSites(
+                [...planeBuses, ...routedBoundaryBuses, candidateBus],
+                {
+                  viaDiameter: this.config.viaDiameter,
+                  viaHoleDiameter: this.config.viaHoleDiameter,
+                  traceWidth: this.config.traceWidth,
+                  clearance: this.config.clearance,
+                  maximumSearchStates: 100_000,
+                  preferredBoundaryPerpendicularSideByBusId,
+                  preferBoundaryOutwardByBusId,
+                  fixedViaPointsByConnectionIndex:
+                    fixedViaPointsByConnectionIndex,
+                  blockingSegments,
+                  canShareCopper,
+                },
+              )
+          if (!extendedViaPoints) continue
+          const previousFixedViaPoints = fixedViaPointsByConnectionIndex
+          const previousPlanCount = matchedPlans.length
+          const laterBuses = remainingBoundaryBuses.filter(
+            (_, laterIndex) => laterIndex !== candidateIndex,
+          )
+          let candidateFixedViaPoints: ReadonlyMap<
+            number,
+            { x: number; y: number }
+          > = extendedViaPoints
+          if (laterBuses.length === 1) {
+            const laterBus = laterBuses[0]!
+            const futureAssignment = matchComponentDogboneViaSites(
+              [...planeBuses, ...routedBoundaryBuses, candidateBus, laterBus],
+              {
+                viaDiameter: this.config.viaDiameter,
+                viaHoleDiameter: this.config.viaHoleDiameter,
+                traceWidth: this.config.traceWidth,
+                clearance: this.config.clearance,
+                maximumSearchStates: 100_000,
+                preferredBoundaryPerpendicularSideByBusId,
+                preferBoundaryOutwardByBusId,
+                fixedViaPointsByConnectionIndex: extendedViaPoints,
+                blockingSegments,
+                canShareCopper,
+              },
+            )
+            if (futureAssignment) {
+              const candidateCountByConnectionIndex = new Map<number, number>()
+              for (const candidate of getComponentDogboneViaSiteCandidates(
+                [laterBus],
+                {
+                  viaDiameter: this.config.viaDiameter,
+                  viaHoleDiameter: this.config.viaHoleDiameter,
+                  traceWidth: this.config.traceWidth,
+                  clearance: this.config.clearance,
+                  blockingSegments,
+                  canShareCopper,
+                },
+              )) {
+                candidateCountByConnectionIndex.set(
+                  candidate.connectionIndex,
+                  (candidateCountByConnectionIndex.get(
+                    candidate.connectionIndex,
+                  ) ?? 0) + 1,
+                )
+              }
+              const constrainedConnections = laterBus.connections.toSorted(
+                (first, second) =>
+                  (candidateCountByConnectionIndex.get(first.connectionIndex) ??
+                    0) -
+                    (candidateCountByConnectionIndex.get(
+                      second.connectionIndex,
+                    ) ?? 0) || first.connectionIndex - second.connectionIndex,
+              )
+              const repairedViaPoints = new Map(extendedViaPoints)
+              for (const connection of constrainedConnections) {
+                const criticalPoint = futureAssignment.get(
+                  connection.connectionIndex,
+                )
+                if (criticalPoint) {
+                  repairedViaPoints.set(
+                    connection.connectionIndex,
+                    criticalPoint,
+                  )
+                }
+              }
+              candidateFixedViaPoints = repairedViaPoints
+            }
+          }
+          fixedViaPointsByConnectionIndex = candidateFixedViaPoints
+          if (routeMatchedBoundaryBus(candidateBus)) {
+            const candidateLeavesAFeasibleExtension =
+              laterBuses.length === 0 ||
+              laterBuses.some((laterBus) => {
+                const lookaheadBlockingSegments = matchedPlans.flatMap((plan) =>
+                  plan.segments.map((segment) => ({
+                    connectionIndex: plan.connectionIndex,
+                    segment,
+                  })),
+                )
+                return Boolean(
+                  matchComponentDogboneViaSites(
+                    [
+                      ...planeBuses,
+                      ...routedBoundaryBuses,
+                      candidateBus,
+                      laterBus,
+                    ],
+                    {
+                      viaDiameter: this.config.viaDiameter,
+                      viaHoleDiameter: this.config.viaHoleDiameter,
+                      traceWidth: this.config.traceWidth,
+                      clearance: this.config.clearance,
+                      maximumSearchStates: 100_000,
+                      preferredBoundaryPerpendicularSideByBusId,
+                      preferBoundaryOutwardByBusId,
+                      fixedViaPointsByConnectionIndex:
+                        fixedViaPointsByConnectionIndex,
+                      blockingSegments: lookaheadBlockingSegments,
+                      canShareCopper,
+                    },
+                  ),
+                )
+              })
+            if (candidateLeavesAFeasibleExtension) {
+              selectedBusIndex = candidateIndex
+              routedBoundaryBuses.push(candidateBus)
+              break
+            }
+            matchedPlans.splice(previousPlanCount)
+          }
+          fixedViaPointsByConnectionIndex = previousFixedViaPoints
+        }
+        if (selectedBusIndex < 0) {
           matchedRoutingSucceeded = false
           break
         }
-        const currentConnectionNames = new Set(
-          bus.connections.map((connection) => connection.connection.name),
-        )
-        const reservedVias = (
-          reservedViasByComponentId.get(bus.componentId) ?? []
-        ).filter(
-          ({ connectionName }) => !currentConnectionNames.has(connectionName),
-        )
-        const busPlans = routeBusAlternatives(
-          {
-            srj: this.routingSrj,
-            bus,
-            targetLayer,
-            acceptedPlans: matchedPlans,
-            layerNames: this.config.layerNames,
-            traceWidth: this.config.traceWidth,
-            viaDiameter: this.config.viaDiameter,
-            viaHoleDiameter: this.config.viaHoleDiameter,
-            clearance: this.config.clearance,
-            compactBusTracks: this.config.compactBusTracks,
-            allowBlindAndBuriedVias: false,
-            allowSameNetMerges: this.config.allowSameNetMerges,
-            staticClearanceCache: this.routeStaticClearanceCache,
-            fixedViaPointsByConnectionIndex,
-            reservedVias,
-            viaMinimalOnly: true,
+        remainingBoundaryBuses.splice(selectedBusIndex, 1)
+      }
+      if (matchedRoutingSucceeded) {
+        let feasibleViaPoints: Map<number, { x: number; y: number }> | null =
+          null
+        const matchViaPointsAroundPlans = (
+          candidatePlans: readonly FanoutRoutePlan[],
+        ): Map<number, { x: number; y: number }> | null => {
+          const fixedBoundaryViaPoints = new Map(
+            candidatePlans.flatMap((plan) =>
+              plan.via
+                ? [[plan.connectionIndex, plan.via.center] as const]
+                : [],
+            ),
+          )
+          return matchComponentDogboneViaSites(
+            [...planeBuses, ...boundaryBuses],
+            {
+              viaDiameter: this.config.viaDiameter,
+              viaHoleDiameter: this.config.viaHoleDiameter,
+              traceWidth: this.config.traceWidth,
+              clearance: this.config.clearance,
+              maximumSearchStates: 100_000,
+              preferredBoundaryPerpendicularSideByBusId,
+              preferBoundaryOutwardByBusId,
+              fixedViaPointsByConnectionIndex: fixedBoundaryViaPoints,
+              blockingSegments: candidatePlans.flatMap((plan) =>
+                plan.segments.map((segment) => ({
+                  connectionIndex: plan.connectionIndex,
+                  segment,
+                })),
+              ),
+              canShareCopper,
+            },
+          )
+        }
+        const matchedLengthResult = matchBusPlanLengths({
+          plans: matchedPlans,
+          preparedBuses: this.preparedBuses,
+          inputSrj: this.inputSrj,
+          sharedBoundary: this.getValidationBoundary(),
+          clearance: this.config.clearance,
+          allowBlindAndBuriedVias: false,
+          allowSameNetMerges: this.config.allowSameNetMerges,
+          allowMatchingInsideDenseBounds: true,
+          candidatePlansAreFeasible: (candidatePlans) => {
+            const candidateViaPoints = matchViaPointsAroundPlans(candidatePlans)
+            if (!candidateViaPoints) return false
+            feasibleViaPoints = candidateViaPoints
+            return true
           },
-          1,
-        )[0]
-        if (!busPlans) {
+        })
+        if (matchedLengthResult.plans) {
+          matchedPlans = matchedLengthResult.plans
+          const rematchedViaPoints =
+            feasibleViaPoints ?? matchViaPointsAroundPlans(matchedPlans)
+          if (rematchedViaPoints) {
+            fixedViaPointsByConnectionIndex = rematchedViaPoints
+          } else {
+            matchedRoutingSucceeded = false
+          }
+        } else {
           matchedRoutingSucceeded = false
-          break
         }
-        matchedPlans.push(...busPlans)
       }
       if (matchedRoutingSucceeded) {
         for (const bus of planeBuses) {

package/lib/match-bus-lengths.ts

@@ -448,6 +448,7 @@ function createTunedPlanCandidates(params: {
   targetAddedLength: number
   clearance: number
   sharedBoundary: Bounds
+  allowInsideDenseBounds?: boolean
   denseBoundarySplitApplied?: boolean
 }): FanoutRoutePlan[] {
   const {
@@ -456,6 +457,7 @@ function createTunedPlanCandidates(params: {
     targetAddedLength,
     clearance,
     sharedBoundary,
+    allowInsideDenseBounds = false,
     denseBoundarySplitApplied = false,
   } = params
   const candidates: FanoutRoutePlan[] = []
@@ -497,6 +499,7 @@ function createTunedPlanCandidates(params: {
             continue
           }
           if (
+            !allowInsideDenseBounds &&
             points
               .slice(1, -1)
               .some(
@@ -575,6 +578,17 @@ export function matchBusPlanLengths(params: {
   clearance: number
   allowBlindAndBuriedVias?: boolean
   allowSameNetMerges?: boolean
+  /**
+   * Allows tuning on target-layer copper inside the component pad envelope.
+   * Intended only for coordinated dense routing whose complete copper is
+   * revalidated and whose remaining dogbone capacity is checked atomically.
+   */
+  allowMatchingInsideDenseBounds?: boolean
+  /**
+   * Rejects a geometrically clear candidate when it would make a caller-owned
+   * downstream assignment (such as pending plane dogbones) infeasible.
+   */
+  candidatePlansAreFeasible?: (plans: readonly FanoutRoutePlan[]) => boolean
 }):
   | { plans: FanoutRoutePlan[]; failedBus?: never }
   | { plans: null; failedBus: PreparedBus } {
@@ -585,6 +599,8 @@ export function matchBusPlanLengths(params: {
     clearance,
     allowBlindAndBuriedVias = true,
     allowSameNetMerges = false,
+    allowMatchingInsideDenseBounds = false,
+    candidatePlansAreFeasible,
   } = params
   let matchedPlans = [...params.plans]
   const constrainedBuses = preparedBuses.filter(
@@ -633,6 +649,95 @@ export function matchBusPlanLengths(params: {
         )
         .toSorted((first, second) => first - second)
       let acceptedPlans: FanoutRoutePlan[] | null = null
+      const acceptCandidate = (
+        candidate: FanoutRoutePlan,
+      ): FanoutRoutePlan[] | null => {
+        const nextPlans = matchedPlans.map((plan) =>
+          plan === shortest ? candidate : plan,
+        )
+        const nextBusPlans = nextPlans.filter(
+          (plan) => plan.busId === bus.busId,
+        )
+        if (getBusSkew(nextBusPlans) > skew + EPSILON) return null
+        if (
+          !fanoutPlansAreClear({
+            plans: nextPlans,
+            srj: inputSrj,
+            sharedBoundary,
+            clearance,
+            allowBlindAndBuriedVias,
+            allowSameNetMerges,
+          })
+        ) {
+          return null
+        }
+        if (
+          candidatePlansAreFeasible &&
+          !candidatePlansAreFeasible(nextPlans)
+        ) {
+          return null
+        }
+        return nextPlans
+      }
+      const findMultiSpanCandidate = (
+        targetAddedLength: number,
+      ): FanoutRoutePlan[] | null => {
+        const maximumSearchStates = 320
+        const maximumCandidatesPerState = 48
+        let searchedStateCount = 0
+        const sampleCandidates = (
+          candidates: readonly FanoutRoutePlan[],
+        ): FanoutRoutePlan[] => {
+          if (candidates.length <= maximumCandidatesPerState) {
+            return [...candidates]
+          }
+          return Array.from(
+            { length: maximumCandidatesPerState },
+            (_, sampleIndex) =>
+              candidates[
+                Math.floor(
+                  (sampleIndex * candidates.length) / maximumCandidatesPerState,
+                )
+              ]!,
+          )
+        }
+        const search = (
+          currentPlan: FanoutRoutePlan,
+          stagesRemaining: number,
+        ): FanoutRoutePlan[] | null => {
+          const addedLength = currentPlan.length - shortest.length
+          const remainingAddition = targetAddedLength - addedLength
+          if (remainingAddition <= EPSILON) {
+            return acceptCandidate(currentPlan)
+          }
+          if (stagesRemaining <= 0) return null
+          const stageAddedLength = remainingAddition / stagesRemaining
+          const candidates = sampleCandidates(
+            createTunedPlanCandidates({
+              plan: currentPlan,
+              bus,
+              targetAddedLength: stageAddedLength,
+              clearance,
+              sharedBoundary: bus.sharedBoundary,
+              allowInsideDenseBounds: allowMatchingInsideDenseBounds,
+            }),
+          )
+          for (const candidate of candidates) {
+            searchedStateCount++
+            if (searchedStateCount > maximumSearchStates) return null
+            if (!acceptCandidate(candidate)) continue
+            const result = search(candidate, stagesRemaining - 1)
+            if (result) return result
+          }
+          return null
+        }
+        for (let stageCount = 2; stageCount <= 8; stageCount++) {
+          const result = search(shortest, stageCount)
+          if (result) return result
+          if (searchedStateCount > maximumSearchStates) break
+        }
+        return null
+      }
       for (const targetAddedLength of targetAddedLengths) {
         const candidates = createTunedPlanCandidates({
           plan: shortest,
@@ -640,31 +745,19 @@ export function matchBusPlanLengths(params: {
           targetAddedLength,
           clearance,
           sharedBoundary: bus.sharedBoundary,
+          allowInsideDenseBounds: allowMatchingInsideDenseBounds,
         })
         for (const candidate of candidates) {
-          const nextPlans = matchedPlans.map((plan) =>
-            plan === shortest ? candidate : plan,
-          )
-          const nextBusPlans = nextPlans.filter(
-            (plan) => plan.busId === bus.busId,
-          )
-          const nextSkew = getBusSkew(nextBusPlans)
-          if (nextSkew > skew + EPSILON) continue
-          if (
-            !fanoutPlansAreClear({
-              plans: nextPlans,
-              srj: inputSrj,
-              sharedBoundary,
-              clearance,
-              allowBlindAndBuriedVias,
-              allowSameNetMerges,
-            })
-          ) {
-            continue
-          }
-          acceptedPlans = nextPlans
+          acceptedPlans = acceptCandidate(candidate)
+          if (!acceptedPlans) continue
           break
         }
+        if (
+          !acceptedPlans &&
+          Math.abs(targetAddedLength - minimumRequiredAddition) <= EPSILON
+        ) {
+          acceptedPlans = findMultiSpanCandidate(targetAddedLength)
+        }
         if (acceptedPlans) break
       }
       if (!acceptedPlans) return { plans: null, failedBus: bus }

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

@@ -33,6 +33,13 @@ export interface DogboneViaSiteGeometryRules {
   preferredBoundaryPerpendicularSideByBusId?: ReadonlyMap<string, -1 | 1>
   /** Prefer the local outward or inward half-pitch row for a boundary bus. */
   preferBoundaryOutwardByBusId?: ReadonlyMap<string, boolean>
+  /** Existing assignments that must be preserved while matching other pads. */
+  fixedViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
+  /** Routed copper that every newly assigned through-via/dogbone must clear. */
+  blockingSegments?: readonly {
+    connectionIndex: number
+    segment: RoutedSegment
+  }[]
   /** True only when the two connections are allowed to merge copper. */
   canShareCopper?: (
     firstConnectionIndex: number,
@@ -69,6 +76,11 @@ interface ConnectionCandidates {
   candidates: ViaSiteCandidate[]
 }
 
+export interface ComponentDogboneViaSiteCandidate {
+  connectionIndex: number
+  point: Point2D
+}
+
 function assertGeometryRules(rules: DogboneViaSiteGeometryRules): number {
   for (const [name, value] of [
     ["viaDiameter", rules.viaDiameter],
@@ -340,9 +352,13 @@ function getConnectionCandidates(params: {
       uniquePoints.push(point)
     }
   }
+  const fixedViaPoint = rules.fixedViaPointsByConnectionIndex?.get(
+    preparedConnection.connectionIndex,
+  )
+  const candidatePoints = fixedViaPoint ? [fixedViaPoint] : uniquePoints
 
   const candidates: ViaSiteCandidate[] = []
-  for (const point of uniquePoints) {
+  for (const point of candidatePoints) {
     if (
       connection.terminationType === "plane" &&
       !directSegmentIsStraightOr45(source, point)
@@ -375,6 +391,38 @@ function getConnectionCandidates(params: {
     ) {
       continue
     }
+    const candidateClearsRoutedCopper = (rules.blockingSegments ?? []).every(
+      (blocker) => {
+        if (blocker.connectionIndex === preparedConnection.connectionIndex) {
+          return true
+        }
+        if (
+          rules.canShareCopper?.(
+            preparedConnection.connectionIndex,
+            blocker.connectionIndex,
+          )
+        ) {
+          return true
+        }
+        const viaToTraceClearance =
+          rules.viaDiameter / 2 + blocker.segment.width / 2 + rules.clearance
+        if (
+          distancePointToSegment(
+            point,
+            blocker.segment.start,
+            blocker.segment.end,
+          ) <
+          viaToTraceClearance - EPSILON
+        ) {
+          return false
+        }
+        return (
+          blocker.segment.layer !== sourceSegment.layer ||
+          segmentsAreClear(sourceSegment, blocker.segment, rules.clearance)
+        )
+      },
+    )
+    if (!candidateClearsRoutedCopper) continue
     candidates.push({
       connectionIndex: preparedConnection.connectionIndex,
       point,
@@ -582,3 +630,26 @@ export function matchComponentDogboneViaSites(
   }
   return result
 }
+
+/**
+ * Enumerates the same statically legal sites used by the component matcher.
+ * This is useful to preserve future dogbone capacity while another bus is
+ * being routed; callers must still run the full matcher afterward because
+ * these candidates are not mutually assigned.
+ */
+export function getComponentDogboneViaSiteCandidates(
+  preparedBuses: readonly PreparedBus[],
+  rules: DogboneViaSiteGeometryRules,
+): ComponentDogboneViaSiteCandidate[] {
+  assertGeometryRules(rules)
+  return getComponentMatchingInputs(preparedBuses).flatMap((component) =>
+    component.connections.flatMap((connection) =>
+      getConnectionCandidates({ connection, component, rules }).map(
+        (candidate) => ({
+          connectionIndex: candidate.connectionIndex,
+          point: { ...candidate.point },
+        }),
+      ),
+    ),
+  )
+}

package/lib/route-bus.ts

@@ -131,14 +131,22 @@ function getStableConnectionIdentity(
   return connection.name
 }
 
-function getWindingTargetRank(params: {
+function getWindingTargetOrders(params: {
   bus: PreparedBus
-  connection: PreparedConnection
   boundaryDirection: FanoutDirection
   layerNames: readonly string[]
-}): { rank: number; connectionCount: number } {
-  const { bus, connection, boundaryDirection, layerNames } = params
-  const orderedConnections = bus.connections.toSorted((first, second) => {
+  targetLayer: string
+}): {
+  orders: PreparedConnection[][]
+  legacyOrder: PreparedConnection[]
+} {
+  const { bus, boundaryDirection, layerNames, targetLayer } = params
+  const getTargetLayer = (candidate: PreparedConnection): string =>
+    candidate.exitTargetPoint?.layer ?? getPointLayer(candidate.targetPoint)
+  const compareWithinLayer = (
+    first: PreparedConnection,
+    second: PreparedConnection,
+  ): number => {
     const axisDifference =
       getPerpendicularAxis(
         first.exitTargetPoint ?? first.targetPoint,
@@ -150,28 +158,114 @@ function getWindingTargetRank(params: {
       )
     if (axisDifference !== 0) return axisDifference
 
-    // Equal target coordinates came from distinct target layers and do not
-    // impose a physical order after this bus is collapsed onto one escape
-    // layer. Keep that free choice independent of allowed-layer ordering so
-    // the local fanout can choose a deterministic, via-minimal permutation.
-    const identityDifference = first.connection.name.localeCompare(
-      second.connection.name,
-    )
-    if (identityDifference !== 0) return identityDifference
-
     const firstStableId = getStableConnectionIdentity(first.connection)
     const secondStableId = getStableConnectionIdentity(second.connection)
     const stableIdentityDifference = firstStableId.localeCompare(secondStableId)
     if (stableIdentityDifference !== 0) return stableIdentityDifference
 
-    const firstLayer = first.exitTargetPoint?.layer
-    const secondLayer = second.exitTargetPoint?.layer
     return (
-      layerNames.indexOf(firstLayer ?? "") -
-        layerNames.indexOf(secondLayer ?? "") ||
+      first.connection.name.localeCompare(second.connection.name) ||
+      first.connectionIndex - second.connectionIndex
+    )
+  }
+  const legacyOrderedConnections = bus.connections.toSorted((first, second) => {
+    const axisDifference =
+      getPerpendicularAxis(
+        first.exitTargetPoint ?? first.targetPoint,
+        boundaryDirection,
+      ) -
+      getPerpendicularAxis(
+        second.exitTargetPoint ?? second.targetPoint,
+        boundaryDirection,
+      )
+    if (axisDifference !== 0) return axisDifference
+    return (
+      first.connection.name.localeCompare(second.connection.name) ||
+      getStableConnectionIdentity(first.connection).localeCompare(
+        getStableConnectionIdentity(second.connection),
+      ) ||
+      layerNames.indexOf(getTargetLayer(first)) -
+        layerNames.indexOf(getTargetLayer(second)) ||
       first.connectionIndex - second.connectionIndex
     )
   })
+  const connectionsByLayer = new Map<string, PreparedConnection[]>()
+  for (const candidate of bus.connections) {
+    const layer = getTargetLayer(candidate)
+    const layerConnections = connectionsByLayer.get(layer) ?? []
+    layerConnections.push(candidate)
+    connectionsByLayer.set(layer, layerConnections)
+  }
+  const orderedLayers = [...connectionsByLayer.keys()].toSorted(
+    (first, second) =>
+      Number(second === targetLayer) - Number(first === targetLayer) ||
+      layerNames.indexOf(first) - layerNames.indexOf(second) ||
+      first.localeCompare(second),
+  )
+  const layerOrderByName = new Map(
+    orderedLayers.map((layer, layerOrder) => [layer, layerOrder]),
+  )
+  const rankWithinLayerByConnectionIndex = new Map<number, number>()
+  for (const layer of orderedLayers) {
+    for (const [rank, candidate] of connectionsByLayer
+      .get(layer)!
+      .toSorted(compareWithinLayer)
+      .entries()) {
+      rankWithinLayerByConnectionIndex.set(candidate.connectionIndex, rank)
+    }
+  }
+  // Winding targets define an order within each copper layer. Their absolute
+  // offsets across different layers are not an ordering constraint: unrelated
+  // buses can move those layer bands without changing this bus's topology.
+  // Build a canonical interleave plus its adjacent linear extensions so a
+  // via-minimal search can choose a locally routable merge without violating
+  // any same-layer winding order.
+  const canonicalOrderedConnections = bus.connections.toSorted(
+    (first, second) =>
+      (rankWithinLayerByConnectionIndex.get(first.connectionIndex) ?? 0) -
+        (rankWithinLayerByConnectionIndex.get(second.connectionIndex) ?? 0) ||
+      (layerOrderByName.get(getTargetLayer(first)) ?? 0) -
+        (layerOrderByName.get(getTargetLayer(second)) ?? 0) ||
+      compareWithinLayer(first, second),
+  )
+  const candidateOrders: PreparedConnection[][] = [canonicalOrderedConnections]
+  for (let index = 0; index + 1 < canonicalOrderedConnections.length; index++) {
+    const first = canonicalOrderedConnections[index]!
+    const second = canonicalOrderedConnections[index + 1]!
+    if (getTargetLayer(first) === getTargetLayer(second)) continue
+    const adjacentExtension = [...canonicalOrderedConnections]
+    adjacentExtension[index] = second
+    adjacentExtension[index + 1] = first
+    candidateOrders.push(adjacentExtension)
+  }
+  // Retain the coordinate-total-order behavior as a compatibility fallback,
+  // but do not let sub-nanometer noise between unrelated layer bands choose
+  // the primary topology.
+  candidateOrders.push(legacyOrderedConnections)
+  const seenOrders = new Set<string>()
+  const orders = candidateOrders.filter((order) => {
+    const key = order.map((candidate) => candidate.connectionIndex).join(",")
+    if (seenOrders.has(key)) return false
+    seenOrders.add(key)
+    return true
+  })
+  return { orders, legacyOrder: legacyOrderedConnections }
+}
+
+function getWindingTargetRank(params: {
+  bus: PreparedBus
+  connection: PreparedConnection
+  boundaryDirection: FanoutDirection
+  layerNames: readonly string[]
+  targetLayer: string
+  windingOrderIndex?: number
+}): { rank: number; connectionCount: number } {
+  const { connection, windingOrderIndex = 0 } = params
+  const { orders, legacyOrder } = getWindingTargetOrders(params)
+  const orderedConnections =
+    params.windingOrderIndex === undefined
+      ? legacyOrder
+      : (orders[windingOrderIndex] ?? orders[0] ?? legacyOrder)
   const rank = orderedConnections.findIndex(
     (candidate) => candidate.connectionIndex === connection.connectionIndex,
   )
@@ -201,6 +295,8 @@ function getCornerTargetTrack(params: {
   viaDiameter: number
   clearance: number
   layerNames: readonly string[]
+  targetLayer: string
+  windingOrderIndex?: number
 }): number {
   const {
     bus,
@@ -210,6 +306,8 @@ function getCornerTargetTrack(params: {
     viaDiameter,
     clearance,
     layerNames,
+    targetLayer,
+    windingOrderIndex,
   } = params
   const side = getCornerSide(bus)
   if (!side || !bus.exitEdge) {
@@ -235,6 +333,8 @@ function getCornerTargetTrack(params: {
         connection,
         boundaryDirection,
         layerNames,
+        targetLayer,
+        windingOrderIndex,
       })
     : undefined
   const bandConnectionCount = Math.max(
@@ -947,6 +1047,7 @@ function buildPlan(params: {
           viaDiameter,
           clearance,
           layerNames,
+          targetLayer,
         })
       : usesLayeredWindingChannel
         ? getPerpendicularAxis(
@@ -2376,8 +2477,18 @@ export function routeBusAlternatives(
       ) => ViaHandedness
       getViaPoint?: (preparedConnection: PreparedConnection) => Point2D
       maximumRouteOrderAttempts?: number
+      windingOrderIndex?: number
+      preferTargetDirectedLaneBias?: boolean
     }
     const maximumThroughAllRouteOrderAttempts = 24
+    const windingTargetOrderCount = cornerSide
+      ? getWindingTargetOrders({
+          bus,
+          boundaryDirection,
+          layerNames,
+          targetLayer,
+        }).orders.length
+      : 1
     const uniformDogboneTerminalPatterns: CoordinatedTerminalPattern[] =
       viaHandednesses.map((viaHandedness) => ({
         label: `uniform-${viaHandedness}`,
@@ -2519,21 +2630,40 @@ export function routeBusAlternatives(
       useViaInPad: true,
       getViaHandedness: () => 0 as const,
     }
-    const fixedViaTerminalPattern: CoordinatedTerminalPattern | undefined =
+    const fixedViaTerminalPatterns: CoordinatedTerminalPattern[] =
       fixedViaPointsByConnectionIndex
-        ? {
-            label: "component-matched-vias",
-            useViaInPad: false,
-            getViaHandedness: () => 0,
-            getViaPoint: (connection) =>
-              fixedViaPointsByConnectionIndex.get(connection.connectionIndex)!,
-            // A fixed component-wide dogbone assignment is a bounded fast
-            // path. Keep enough order/bias attempts for the eight-lane DDR
-            // cases without allowing route-order rotations to grow with an
-            // arbitrarily wide bus.
-            maximumRouteOrderAttempts: maximumThroughAllRouteOrderAttempts,
-          }
-        : undefined
+        ? [
+            ...Array.from(
+              { length: windingTargetOrderCount },
+              (_, windingOrderIndex) => ({
+                label: `component-matched-vias-winding-${windingOrderIndex}`,
+                useViaInPad: false,
+                getViaHandedness: () => 0 as const,
+                getViaPoint: (connection: PreparedConnection) =>
+                  fixedViaPointsByConnectionIndex.get(
+                    connection.connectionIndex,
+                  )!,
+                maximumRouteOrderAttempts: 1,
+                windingOrderIndex,
+                preferTargetDirectedLaneBias: true,
+              }),
+            ),
+            {
+              label: "component-matched-vias-fallback",
+              useViaInPad: false,
+              getViaHandedness: () => 0,
+              getViaPoint: (connection) =>
+                fixedViaPointsByConnectionIndex.get(
+                  connection.connectionIndex,
+                )!,
+              // Preserve the existing bounded search after every inexpensive
+              // layer-interleave candidate has had one deterministic attempt.
+              maximumRouteOrderAttempts: maximumThroughAllRouteOrderAttempts,
+              windingOrderIndex: 0,
+              preferTargetDirectedLaneBias: true,
+            },
+          ]
+        : []
     const planeTerminationsAlreadyOccupyTheFanout = acceptedPlans.some(
       (plan) => plan.termination.type === "plane",
     )
@@ -2545,8 +2675,8 @@ export function routeBusAlternatives(
         ? [...mixedDogboneTerminalPatterns, ...uniformDogboneTerminalPatterns]
         : [...uniformDogboneTerminalPatterns, ...mixedDogboneTerminalPatterns]
     const terminalPatterns: CoordinatedTerminalPattern[] =
-      fixedViaTerminalPattern
-        ? [fixedViaTerminalPattern]
+      fixedViaTerminalPatterns.length > 0
+        ? fixedViaTerminalPatterns
         : canUseViaInPadTerminals
           ? planeTerminationsAlreadyOccupyTheFanout
             ? [viaInPadTerminalPattern, ...dogboneTerminalPatterns]
@@ -2566,6 +2696,8 @@ export function routeBusAlternatives(
               viaDiameter,
               clearance,
               layerNames,
+              targetLayer,
+              windingOrderIndex: terminalPattern.windingOrderIndex,
             })
           : getPerpendicularAxis(
               preparedConnection.exitTargetPoint ??
@@ -2597,12 +2729,12 @@ export function routeBusAlternatives(
           ),
         }
       })
-      const terminalSignature = terminals
+      const terminalSignature = `${terminals
         .map(
           (terminal) =>
-            `${terminal.connection.connectionIndex}:${terminal.viaPoint.x}:${terminal.viaPoint.y}`,
+            `${terminal.connection.connectionIndex}:${terminal.viaPoint.x}:${terminal.viaPoint.y}:${terminal.exitPoint.x}:${terminal.exitPoint.y}`,
         )
-        .join("|")
+        .join("|")}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}`
       if (seenTerminalSignatures.has(terminalSignature)) continue
       seenTerminalSignatures.add(terminalSignature)
       const viaMinimalAlternatives = routeViaMinimalWindingAlternatives(
@@ -2628,10 +2760,14 @@ export function routeBusAlternatives(
               traceWidth + clearance
               ? 2
               : 1,
+          preferTargetDirectedLaneBias:
+            terminalPattern.preferTargetDirectedLaneBias,
         },
-        terminalPattern.maximumRouteOrderAttempts === undefined
-          ? Math.min(2, maxAlternatives - alternatives.length)
-          : 2,
+        fixedViaPointsByConnectionIndex && viaMinimalOnly
+          ? Math.min(2, Math.max(1, maxAlternatives - alternatives.length))
+          : terminalPattern.maximumRouteOrderAttempts === undefined
+            ? Math.min(2, maxAlternatives - alternatives.length)
+            : 2,
       )
       for (const viaMinimalPlans of viaMinimalAlternatives) {
         const combinedPlansAreClear = fanoutPlansAreClear({

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

@@ -60,6 +60,8 @@ export interface RouteViaMinimalWindingParams {
   reservedVias?: 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. */
+  preferTargetDirectedLaneBias?: boolean
 }
 
 interface GridNode {
@@ -600,6 +602,7 @@ export function routeViaMinimalWindingAlternatives(
     maximumRouteOrderAttempts,
     reservedVias = [],
     gridStepDivisor = 1,
+    preferTargetDirectedLaneBias = false,
   } = params
   if (
     maximumRouteOrderAttempts !== undefined &&
@@ -723,7 +726,6 @@ export function routeViaMinimalWindingAlternatives(
     }
     return low
   }
-
   const segmentIsClear = (params: {
     segment: RoutedSegment
     terminal: ViaMinimalWindingTerminal
@@ -842,7 +844,7 @@ export function routeViaMinimalWindingAlternatives(
           nodeIndex,
           points,
           radialDistance: connectorDistance,
-          length: getSegments(points, traceWidth, targetLayer).reduce(
+          length: segments.reduce(
             (total, segment) => total + distance(segment.start, segment.end),
             0,
           ),
@@ -1073,15 +1075,31 @@ export function routeViaMinimalWindingAlternatives(
   const targetTracks = targetOrderedTerminals.map((terminal) =>
     getPerpendicularAxis(terminal.exitPoint, boundaryDirection),
   )
+  const meanViaTrack =
+    viaTracks.reduce((sum, track) => sum + track, 0) / viaTracks.length
+  const meanTargetTrack =
+    targetTracks.reduce((sum, track) => sum + track, 0) / targetTracks.length
   const viasAreBeforeTargets =
     Math.max(...viaTracks) < Math.min(...targetTracks) - EPSILON
   const viasAreAfterTargets =
     Math.min(...viaTracks) > Math.max(...targetTracks) + EPSILON
-  const laneBiases = viasAreBeforeTargets
-    ? ([1, 0, -1] as const)
-    : viasAreAfterTargets
-      ? ([-1, 0, 1] as const)
-      : ([0, 1, -1] as const)
+  const laneBiases = preferTargetDirectedLaneBias
+    ? viasAreBeforeTargets
+      ? ([0, 1, -1] as const)
+      : viasAreAfterTargets
+        ? ([0, -1, 1] as const)
+        : bus.direction === boundaryDirection &&
+            meanTargetTrack > meanViaTrack + EPSILON
+          ? ([1, 0, -1] as const)
+          : bus.direction === boundaryDirection &&
+              meanTargetTrack < meanViaTrack - EPSILON
+            ? ([-1, 0, 1] as const)
+            : ([0, 1, -1] as const)
+    : viasAreBeforeTargets
+      ? ([1, 0, -1] as const)
+      : viasAreAfterTargets
+        ? ([-1, 0, 1] as const)
+        : ([0, 1, -1] as const)
   const initialRouteOrderFactories: Array<
     () => readonly ViaMinimalWindingTerminal[]
   > = []
@@ -1094,8 +1112,19 @@ export function routeViaMinimalWindingAlternatives(
     initialRouteOrderFactories.push(() => [...targetOrderedTerminals].reverse())
   }
   initialRouteOrderFactories.push(
-    () => targetOrderedTerminals,
-    () => [...targetOrderedTerminals].reverse(),
+    ...(preferTargetDirectedLaneBias &&
+    bus.direction === boundaryDirection &&
+    meanTargetTrack < meanViaTrack - EPSILON &&
+    !viasAreBeforeTargets &&
+    !viasAreAfterTargets
+      ? [
+          () => [...targetOrderedTerminals].reverse(),
+          () => targetOrderedTerminals,
+        ]
+      : [
+          () => targetOrderedTerminals,
+          () => [...targetOrderedTerminals].reverse(),
+        ]),
     () =>
       terminals.toSorted(
         (first, second) =>
@@ -1201,7 +1230,9 @@ export function routeViaMinimalWindingAlternatives(
       if (seenAlternativeKeys.has(alternativeKey)) continue
       seenAlternativeKeys.add(alternativeKey)
       alternatives.push(plans)
-      if (alternatives.length >= maximumAlternatives) return alternatives
+      if (alternatives.length >= maximumAlternatives) {
+        return alternatives
+      }
     }
   }
   return alternatives

package/package.json

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