@tscircuit/fanout-solver 0.0.50 → 0.0.52

package/README.md

@@ -280,6 +280,54 @@ parameters. Each sample has one shared boundary around all of its footprints,
 and component bounds come from the exact footprinter-generated copper pad
 extents.
 
+## All-sample benchmark
+
+Run `./benchmark.sh` (or `bun run benchmark`) to benchmark every available sample:
+Datasets 01–08, SRJ19, and SRJ29, currently **421 samples**. New samples in these
+catalogs are discovered automatically; no test-file allowlist is involved.
+
+```sh
+./benchmark.sh
+./benchmark.sh --list
+./benchmark.sh --dataset dataset08
+./benchmark.sh --dataset srj19,srj29 --sample sample001
+./benchmark.sh --concurrency 8 --sample-timeout-seconds 300
+```
+
+Each sample runs in an isolated process, with up to four concurrent processes
+locally and a **120-second hard timeout** by default. A synchronous solver hang,
+exception, or unsolved case does not prevent later samples from running.
+Assignment budgets and circuit constraints remain at each sample's defaults;
+`--max-layer-combinations` explicitly overrides only the search budget.
+
+The ordered `benchmark-results/benchmark.json` and `benchmark.md` reports contain
+the commit, configuration, per-dataset 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.
+Compare reports with the same budgets to track progress. Solved means validated
+fanout, not downstream inter-chip routing; SRJ29 additionally requires its
+original-endpoint and emitted-copper DRC checks. Partial, error, and timeout rows
+are benchmark results (exit 0); invalid CLI arguments or report I/O failures are
+command failures (nonzero exit).
+
+### PR comment trigger
+
+Once `.github/workflows/benchmark.yml` is on the default branch, a repository
+writer can comment **`/benchmark`** on an open PR. The workflow captures that
+PR's exact head SHA, runs all samples on a **32-vCPU Blacksmith ARM** runner,
+then updates a status comment with solve totals, per-sample results, and a link
+to the complete JSON/Markdown artifact. The Actions UI also supports a manual
+run, optionally supplying an open PR number. No custom bot token is required.
+
+The runner defaults to 32 processes and a 120-second per-sample deadline; set
+repository variables `BENCHMARK_CONCURRENCY` and
+`BENCHMARK_SAMPLE_TIMEOUT_SECONDS` to change these. PR code runs with a read-only
+token and no persisted checkout credentials. A separate job uses the trusted
+workflow revision to validate report data and post comments; it never executes
+PR code. Only exact commands from non-bot users with current write, maintain, or
+admin access are accepted.
+
 ## SRJ29 benchmark
 
 The repository loads all 200 samples from the derivative
@@ -293,10 +341,10 @@ direction. Every adapted problem uses the same six-layer stackup (`top`,
 `inner1` through `inner4`, and `bottom`) so benchmark improvements are directly
 comparable.
 
-Run the full benchmark with:
+The dedicated legacy SRJ29 report remains available with:
 
 ```sh
-./benchmark.sh
+bun run benchmark:srj29
 ```
 
 Use `--sample sample001`, `--limit 10`, or

package/lib/fanout-solver.ts

@@ -1710,6 +1710,46 @@ export class FanoutSolver extends BaseSolver {
             : getExitEdgeForDirection(bus.direction) !== bus.exitEdge,
       ]),
     )
+    // An outward half-pitch dogbone can enter a neighboring wide bus's pad
+    // field when a corner bus first escapes toward the package center. Keep
+    // those through-barrels on the opposite side before any earlier bus
+    // commits copper; rematching after that point can be too late.
+    for (const bus of wideBoundaryBuses) {
+      if (useConfiguredDensePlaneRouting) continue
+      if (!getCornerBandSide(bus.exitEdge, bus.preferredExit)) continue
+      const entersNeighboringSourceField = wideBoundaryBuses.some((other) => {
+        if (other === bus || other.componentId !== bus.componentId) return false
+        const xs = other.connections.map(
+          (connection) => connection.sourcePoint.x,
+        )
+        const ys = other.connections.map(
+          (connection) => connection.sourcePoint.y,
+        )
+        const minX = Math.min(...xs)
+        const maxX = Math.max(...xs)
+        const minY = Math.min(...ys)
+        const maxY = Math.max(...ys)
+        return bus.connections.some(({ sourcePoint }) => {
+          const x =
+            sourcePoint.x +
+            (bus.direction === "left"
+              ? -bus.pitchX / 2
+              : bus.direction === "right"
+                ? bus.pitchX / 2
+                : 0)
+          const y =
+            sourcePoint.y +
+            (bus.direction === "down"
+              ? -bus.pitchY / 2
+              : bus.direction === "up"
+                ? bus.pitchY / 2
+                : 0)
+          return x >= minX && x <= maxX && y >= minY && y <= maxY
+        })
+      })
+      if (entersNeighboringSourceField)
+        preferBoundaryOutwardByBusId.set(bus.busId, false)
+    }
     const debugFlippedBoundaryBus = process.env.FANOUT_DEBUG_FLIP_BOUNDARY_BUS
     if (debugFlippedBoundaryBus) {
       preferredBoundaryPerpendicularSideByBusId.set(debugFlippedBoundaryBus, -1)
@@ -1859,9 +1899,17 @@ export class FanoutSolver extends BaseSolver {
       ...(process.env.FANOUT_DEBUG_PROVISIONAL_NARROW === "1"
         ? boundaryBuses.filter((bus) => bus.connections.length < 8)
         : []),
-      ...singletonDeferralCandidates.filter(
-        (bus) => !leadingWideSingletonBuses.includes(bus),
-      ),
+      ...singletonDeferralCandidates.filter((bus) => {
+        const containingBus = getContainingWideSourceField(bus)
+        const sharesContainingBusLayer =
+          !useConfiguredDensePlaneRouting &&
+          containingBus &&
+          params.busLayerAssignments[containingBus.busId] ===
+            params.busLayerAssignments[bus.busId]
+        return (
+          !leadingWideSingletonBuses.includes(bus) && !sharesContainingBusLayer
+        )
+      }),
       ...(hasThreeWideBoundaryBuses
         ? boundaryBuses.filter(
             (bus) =>
@@ -2088,6 +2136,13 @@ export class FanoutSolver extends BaseSolver {
         if (!targetLayer) {
           return false
         }
+        const adaptiveWindingRouteOrder =
+          !useConfiguredDensePlaneRouting &&
+          !getCornerBandSide(bus.exitEdge, bus.preferredExit) &&
+          bus.connections.length > 2 &&
+          wideBoundaryBuses.some((candidate) =>
+            getCornerBandSide(candidate.exitEdge, candidate.preferredExit),
+          )
         const routeParams = {
           srj: this.routingSrj,
           bus,
@@ -2105,9 +2160,14 @@ export class FanoutSolver extends BaseSolver {
           fixedViaPointsByConnectionIndex,
           reservedVias: getReservedVias(bus),
           viaMinimalOnly: process.env.FANOUT_DEBUG_ALLOW_EXTRA_VIAS !== "1",
-          fixedViaFallbackRouteOrderAttempts: useConfiguredDensePlaneRouting
-            ? 6
-            : 24,
+          allowBoundarySideViaFallback: !useConfiguredDensePlaneRouting,
+          adaptiveWindingRouteOrder,
+          alignWindingGridToPads: !useConfiguredDensePlaneRouting,
+          fixedViaFallbackRouteOrderAttempts: adaptiveWindingRouteOrder
+            ? 60
+            : useConfiguredDensePlaneRouting
+              ? 6
+              : 24,
           cornerBandTargetTrackOffset: getCornerBandTargetTrackOffset(bus),
         } as const
         const routeAlternatives = function* (
@@ -2158,6 +2218,88 @@ export class FanoutSolver extends BaseSolver {
         if (!busPlans && preferSingleLayerWinding) {
           busPlans = (yield* routeAlternatives(routeParams, 1))[0]
         }
+        if (!busPlans && !useConfiguredDensePlaneRouting) {
+          const originalPoints = fixedViaPointsByConnectionIndex
+          const originalOutward =
+            preferBoundaryOutwardByBusId.get(bus.busId) ?? true
+          const originalSide =
+            preferredBoundaryPerpendicularSideByBusId.get(bus.busId) ?? 1
+          for (const [outward, side] of [
+            [!originalOutward, originalSide],
+            [originalOutward, -originalSide],
+            [!originalOutward, -originalSide],
+          ] as const) {
+            const rematchedPoints = matchComponentDogboneViaSites(
+              [
+                ...new Set([
+                  ...activeBoundaryReservationPlaneBuses,
+                  ...initiallyMatchedBoundaryBuses,
+                  ...this.preparedBuses.filter((candidate) =>
+                    matchedPlans.some((plan) => plan.busId === candidate.busId),
+                  ),
+                  bus,
+                ]),
+              ],
+              {
+                viaDiameter: this.config.viaDiameter,
+                viaHoleDiameter: this.config.viaHoleDiameter,
+                traceWidth: this.config.traceWidth,
+                clearance: this.config.clearance,
+                maximumSearchStates: 100_000,
+                preferredBoundaryPerpendicularSideByBusId: new Map([
+                  ...preferredBoundaryPerpendicularSideByBusId,
+                  [bus.busId, side as -1 | 1],
+                ]),
+                preferBoundaryOutwardByBusId: new Map([
+                  ...preferBoundaryOutwardByBusId,
+                  [bus.busId, outward],
+                ]),
+                fixedViaPointsByConnectionIndex: new Map(
+                  matchedPlans
+                    .filter((plan) => plan.via)
+                    .map((plan) => [plan.connectionIndex, plan.via!.center]),
+                ),
+                preferredViaPointsByConnectionIndex: new Map(
+                  [...originalPoints].filter(
+                    ([index]) =>
+                      !bus.connections.some(
+                        (connection) => connection.connectionIndex === index,
+                      ),
+                  ),
+                ),
+                blockingSegments: matchedPlans.flatMap((plan) =>
+                  plan.segments.map((segment) => ({
+                    connectionIndex: plan.connectionIndex,
+                    segment,
+                  })),
+                ),
+                additionalObstacles: this.routingSrj.obstacles,
+                preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+                canShareCopper,
+              },
+            )
+            debugDense(
+              "retry-sites",
+              bus.busId,
+              outward,
+              side,
+              rematchedPoints?.size ?? "failed",
+            )
+            if (!rematchedPoints) continue
+            fixedViaPointsByConnectionIndex = rematchedPoints
+            busPlans = (yield* routeAlternatives(
+              {
+                ...routeParams,
+                fixedViaPointsByConnectionIndex: rematchedPoints,
+                reservedVias: getReservedVias(bus),
+                fixedViaFallbackRouteOrderAttempts: 3,
+              },
+              1,
+            ))[0]
+            if (busPlans) break
+          }
+          if (!busPlans) fixedViaPointsByConnectionIndex = originalPoints
+        }
         if (busPlans && bus.maxLengthSkew !== undefined) {
           const lengths = busPlans.map((plan) => plan.length)
           const rawSkew = Math.max(...lengths) - Math.min(...lengths)
@@ -2503,6 +2645,50 @@ export class FanoutSolver extends BaseSolver {
               segment,
             })),
           )
+          const boundaryBusesToMatch = useConfiguredDensePlaneRouting
+            ? boundaryBuses
+            : []
+          const blockingVias = useConfiguredDensePlaneRouting
+            ? []
+            : candidatePlans.flatMap((plan) =>
+                [
+                  plan.via,
+                  ...(plan.additionalVias ?? []),
+                  plan.planeEndpointVia,
+                ]
+                  .filter((via) => via !== undefined)
+                  .map((via) => ({
+                    connectionIndex: plan.connectionIndex,
+                    center: via!.center,
+                    diameter: via!.diameter,
+                    spanLayers: via!.spanLayers,
+                  })),
+              )
+          // Completed boundary paths can reach their via with several source-
+          // layer segments. Treat their actual copper as fixed obstacles instead
+          // of reinterpreting each as a straight pad-to-via dogbone.
+          const retainedViaPoints = useConfiguredDensePlaneRouting
+            ? null
+            : matchComponentDogboneViaSites(planeBuses, {
+                viaDiameter: this.config.viaDiameter,
+                viaHoleDiameter: this.config.viaHoleDiameter,
+                traceWidth: this.config.traceWidth,
+                clearance: this.config.clearance,
+                maximumSearchStates: 1,
+                preferredBoundaryPerpendicularSideByBusId,
+                preferBoundaryOutwardByBusId,
+                fixedViaPointsByConnectionIndex: new Map([
+                  ...fixedViaPointsByConnectionIndex,
+                  ...fixedBoundaryViaPoints,
+                ]),
+                blockingSegments,
+                blockingVias,
+                additionalObstacles: denseAdditionalObstacles,
+                preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+                canShareCopper,
+              })
+          if (retainedViaPoints)
+            return new Map([...fixedBoundaryViaPoints, ...retainedViaPoints])
           if (
             useConfiguredDensePlaneRouting ||
             process.env.FANOUT_DEBUG_INCREMENTAL_PLANE_MATCH === "1"
@@ -2551,7 +2737,7 @@ export class FanoutSolver extends BaseSolver {
               (planeBus) =>
                 !matchedPlaneBuses.includes(planeBus) &&
                 !matchComponentDogboneViaSites(
-                  [...matchedPlaneBuses, planeBus, ...boundaryBuses],
+                  [...matchedPlaneBuses, planeBus, ...boundaryBusesToMatch],
                   {
                     viaDiameter: this.config.viaDiameter,
                     viaHoleDiameter: this.config.viaHoleDiameter,
@@ -2562,6 +2748,7 @@ export class FanoutSolver extends BaseSolver {
                     preferBoundaryOutwardByBusId,
                     fixedViaPointsByConnectionIndex: incrementalViaPoints,
                     blockingSegments,
+                    blockingVias,
                     additionalObstacles: denseAdditionalObstacles,
                     preferPlaneCheckerboardSites:
                       useConfiguredDensePlaneRouting,
@@ -3212,7 +3399,7 @@ export class FanoutSolver extends BaseSolver {
                 )
               }
               const nextViaPoints = matchComponentDogboneViaSites(
-                [...matchedPlaneBuses, planeBus, ...boundaryBuses],
+                [...matchedPlaneBuses, planeBus, ...boundaryBusesToMatch],
                 {
                   viaDiameter: this.config.viaDiameter,
                   viaHoleDiameter: this.config.viaHoleDiameter,
@@ -3223,7 +3410,7 @@ export class FanoutSolver extends BaseSolver {
                   preferBoundaryOutwardByBusId,
                   fixedViaPointsByConnectionIndex: incrementalViaPoints,
                   blockingSegments: allBlockingSegments,
-                  blockingVias: alternateBlockingVias,
+                  blockingVias: [...blockingVias, ...alternateBlockingVias],
                   additionalObstacles: denseAdditionalObstacles,
                   preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
                   canShareCopper,
@@ -3256,8 +3443,8 @@ export class FanoutSolver extends BaseSolver {
             )
             return incrementalViaPoints
           }
-          return matchComponentDogboneViaSites(
-            [...planeBuses, ...boundaryBuses],
+          const planeViaPoints = matchComponentDogboneViaSites(
+            [...planeBuses, ...boundaryBusesToMatch],
             {
               viaDiameter: this.config.viaDiameter,
               viaHoleDiameter: this.config.viaHoleDiameter,
@@ -3268,11 +3455,15 @@ export class FanoutSolver extends BaseSolver {
               preferBoundaryOutwardByBusId,
               fixedViaPointsByConnectionIndex: fixedBoundaryViaPoints,
               blockingSegments,
+              blockingVias,
               additionalObstacles: denseAdditionalObstacles,
               preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
               canShareCopper,
             },
           )
+          return planeViaPoints
+            ? new Map([...fixedBoundaryViaPoints, ...planeViaPoints])
+            : null
         }
         debugDense("length-match:start", matchedPlans.length)
         const matchedLengthResult = matchBusPlanLengths({

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

@@ -35,6 +35,8 @@ export interface DogboneViaSiteGeometryRules {
   preferBoundaryOutwardByBusId?: ReadonlyMap<string, boolean>
   /** Existing assignments that must be preserved while matching other pads. */
   fixedViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
+  /** Prefer these provisional sites, but allow rematching when they conflict. */
+  preferredViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
   /** Routed copper that every newly assigned through-via/dogbone must clear. */
   blockingSegments?: readonly {
     connectionIndex: number
@@ -506,6 +508,9 @@ function getConnectionCandidates(params: {
     connection.terminationType === "boundary"
       ? (rules.preferBoundaryOutwardByBusId?.get(connection.busId) ?? true)
       : true
+  const preferredViaPoint = rules.preferredViaPointsByConnectionIndex?.get(
+    preparedConnection.connectionIndex,
+  )
   const getPerpendicularPreferenceRank = (
     candidate: ViaSiteCandidate,
   ): number => {
@@ -522,6 +527,10 @@ function getConnectionCandidates(params: {
   }
   return candidates.toSorted(
     (first, second) =>
+      (preferredViaPoint
+        ? Number(distance(first.point, preferredViaPoint) > EPSILON) -
+          Number(distance(second.point, preferredViaPoint) > EPSILON)
+        : 0) ||
       (preferOutward
         ? first.outwardRank - second.outwardRank
         : second.outwardRank - first.outwardRank) ||

package/lib/route-bus.ts

@@ -19,6 +19,7 @@ import {
 } from "./geometry"
 import { getAllRoutedTraceCopper } from "./get-routed-trace-copper"
 import { getViaSpanLayers } from "./layer-names"
+import { matchComponentDogboneViaSites } from "./match-component-dogbone-via-sites"
 import {
   connectionsShareElectricalNet,
   obstacleSharesElectricalNet,
@@ -61,6 +62,12 @@ export interface RouteBusParams {
   fixedViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
   reservedVias?: readonly ViaMinimalWindingReservedVia[]
   viaMinimalOnly?: boolean
+  /** Permit a singleton to move its provisional via near the boundary. */
+  allowBoundarySideViaFallback?: boolean
+  /** Retry blocked winding terminals ahead of already-routed terminals. */
+  adaptiveWindingRouteOrder?: boolean
+  /** Preserve pad-lattice channels in the automatic dense routing path. */
+  alignWindingGridToPads?: boolean
   /** Bounds the final fixed-via winding fallback after ordered attempts. */
   fixedViaFallbackRouteOrderAttempts?: number
   /** Skip this many otherwise-clear plane escapes when enumerating alternatives. */
@@ -2444,6 +2451,9 @@ export function* routeBusAlternativesSteps(
     fixedViaPointsByConnectionIndex,
     reservedVias = [],
     viaMinimalOnly = false,
+    allowBoundarySideViaFallback = false,
+    adaptiveWindingRouteOrder = false,
+    alignWindingGridToPads = false,
     fixedViaFallbackRouteOrderAttempts = 24,
     cornerBandTargetTrackOffset,
   } = params
@@ -2723,8 +2733,36 @@ export function* routeBusAlternativesSteps(
       useViaInPad: true,
       getViaHandedness: () => 0 as const,
     }
+    const coordinatedViaPoints =
+      fixedViaPointsByConnectionIndex ??
+      (!allowBlindAndBuriedVias &&
+      bus.connections.length >= 8 &&
+      reservedVias.length === 0
+        ? matchComponentDogboneViaSites([bus], {
+            viaDiameter,
+            viaHoleDiameter,
+            traceWidth,
+            clearance,
+            additionalObstacles: srj.obstacles,
+            blockingSegments: acceptedPlans.flatMap((plan) =>
+              getPlanSegments(plan).map((segment) => ({
+                connectionIndex: plan.connectionIndex,
+                segment,
+              })),
+            ),
+            blockingVias: acceptedPlans.flatMap((plan) =>
+              getPlanVias(plan).map((via) => ({
+                connectionIndex: plan.connectionIndex,
+                ...via.center,
+                center: via.center,
+                diameter: via.diameter,
+                spanLayers: via.spanLayers,
+              })),
+            ),
+          })
+        : null)
     const fixedViaTerminalPatterns: CoordinatedTerminalPattern[] =
-      fixedViaPointsByConnectionIndex
+      coordinatedViaPoints
         ? [
             ...Array.from(
               { length: windingTargetOrderCount },
@@ -2733,9 +2771,7 @@ export function* routeBusAlternativesSteps(
                 useViaInPad: false,
                 getViaHandedness: () => 0 as const,
                 getViaPoint: (connection: PreparedConnection) =>
-                  fixedViaPointsByConnectionIndex.get(
-                    connection.connectionIndex,
-                  )!,
+                  coordinatedViaPoints.get(connection.connectionIndex)!,
                 maximumRouteOrderAttempts: 1,
                 windingOrderIndex,
                 preferTargetDirectedLaneBias: true,
@@ -2746,9 +2782,7 @@ export function* routeBusAlternativesSteps(
               useViaInPad: false,
               getViaHandedness: () => 0,
               getViaPoint: (connection) =>
-                fixedViaPointsByConnectionIndex.get(
-                  connection.connectionIndex,
-                )!,
+                coordinatedViaPoints.get(connection.connectionIndex)!,
               // Preserve the existing bounded search after every inexpensive
               // layer-interleave candidate has had one deterministic attempt.
               maximumRouteOrderAttempts: fixedViaFallbackRouteOrderAttempts,
@@ -2846,9 +2880,13 @@ export function* routeBusAlternativesSteps(
           allowBlindAndBuriedVias,
           allowSameNetMerges,
           maximumRouteOrderAttempts: terminalPattern.maximumRouteOrderAttempts,
+          adaptiveRouteOrder: adaptiveWindingRouteOrder,
+          alignGridToPads:
+            alignWindingGridToPads ||
+            Boolean(coordinatedViaPoints && !fixedViaPointsByConnectionIndex),
           reservedVias,
           gridStepDivisor:
-            fixedViaPointsByConnectionIndex &&
+            coordinatedViaPoints &&
             Math.min(bus.pitchX, bus.pitchY) -
               2 * (viaDiameter / 2 + traceWidth / 2 + clearance) <
               traceWidth + clearance
@@ -2907,6 +2945,204 @@ export function* routeBusAlternativesSteps(
     }
   }
 
+  // A through-via does not have to sit next to the source pad. A singleton
+  // embedded in another bus's source field can have every local dogbone site
+  // occupied while still having a clear top-layer escape. In that case, route
+  // to one via near the boundary and make the short final hop on the requested
+  // escape layer. This retains the one-via invariant and avoids weakening any
+  // clearance rule.
+  if (
+    alternatives.length === 0 &&
+    allowBoundarySideViaFallback &&
+    fixedViaPointsByConnectionIndex &&
+    bus.connections.length === 1 &&
+    bus.exitEdge &&
+    bus.connections[0]!.sourceLayer !== targetLayer
+  ) {
+    const preparedConnection = bus.connections[0]!
+    const boundaryDirection = getDirectionForExitEdge(bus.exitEdge)
+    const boundaryExitAxis = getExitAxis(bus, boundaryDirection)
+    const finalTrack = getBoundaryTargetTrack({
+      bus,
+      connection: preparedConnection,
+      boundaryDirection,
+    })
+    const finalExitPoint = makePoint(
+      boundaryExitAxis,
+      finalTrack,
+      boundaryDirection,
+    )
+    const sourceLayerSrj: SimpleRouteJson = {
+      ...srj,
+      obstacles: srj.obstacles.map((obstacle) =>
+        obstacle === preparedConnection.sourceObstacle ||
+        (distance(obstacle.center, preparedConnection.sourcePoint) <= 1e-7 &&
+          obstacle.layers.includes(preparedConnection.sourceLayer))
+          ? {
+              ...obstacle,
+              connectedTo: [
+                ...obstacle.connectedTo,
+                preparedConnection.connection.name,
+              ],
+            }
+          : obstacle,
+      ),
+    }
+    const insetStep = Math.max(
+      viaDiameter / 2 + clearance,
+      Math.min(bus.pitchX, bus.pitchY) / 2,
+    )
+    for (const multiple of [1, 2, 3, 4, 5]) {
+      const inset = multiple * insetStep
+      const boundaryViaPoint = makePoint(
+        boundaryExitAxis - directionSign(boundaryDirection) * inset,
+        finalTrack,
+        boundaryDirection,
+      )
+      const sourceLayerSteps = routeViaMinimalWindingAlternativesSteps(
+        {
+          srj: sourceLayerSrj,
+          bus,
+          targetLayer: preparedConnection.sourceLayer,
+          terminals: [
+            {
+              connection: preparedConnection,
+              viaPoint: preparedConnection.sourcePoint,
+              exitPoint: boundaryViaPoint,
+            },
+          ],
+          acceptedPlans,
+          layerNames,
+          traceWidth,
+          viaDiameter,
+          viaHoleDiameter,
+          clearance,
+          allowBlindAndBuriedVias,
+          allowSameNetMerges,
+          maximumRouteOrderAttempts: 3,
+          reservedVias,
+          gridStepDivisor: 2,
+          allowSourceLayerRouting: true,
+          alignGridToPads: true,
+        },
+        1,
+        includeVisualization,
+      )
+      let sourceLayerResult = sourceLayerSteps.next()
+      while (!sourceLayerResult.done) {
+        yield {
+          phase: "via-minimal-winding",
+          busId: bus.busId,
+          targetLayer: preparedConnection.sourceLayer,
+          winding: sourceLayerResult.value,
+        }
+        sourceLayerResult = sourceLayerSteps.next()
+      }
+      const sourceLayerPlan = sourceLayerResult.value[0]?.[0]
+      if (!sourceLayerPlan) continue
+      const targetSegment: RoutedSegment = {
+        start: boundaryViaPoint,
+        end: finalExitPoint,
+        width: traceWidth,
+        layer: targetLayer,
+      }
+      const via = {
+        center: boundaryViaPoint,
+        diameter: viaDiameter,
+        holeDiameter: viaHoleDiameter,
+        fromLayer: preparedConnection.sourceLayer,
+        toLayer: targetLayer,
+        spanLayers: getViaSpanLayers({
+          fromLayer: preparedConnection.sourceLayer,
+          toLayer: targetLayer,
+          layerNames,
+          allowBlindAndBuriedVias,
+        }),
+      }
+      const sourceRoute = sourceLayerPlan.trace.route.filter(
+        (item) => item.route_type === "wire",
+      )
+      const plans: FanoutRoutePlan[] = [
+        {
+          ...sourceLayerPlan,
+          targetLayer,
+          exitPoint: finalExitPoint,
+          via,
+          segments: [...sourceLayerPlan.segments, targetSegment],
+          length:
+            sourceLayerPlan.length + distance(boundaryViaPoint, finalExitPoint),
+          trace: {
+            ...sourceLayerPlan.trace,
+            route: [
+              ...sourceRoute,
+              {
+                route_type: "via",
+                ...boundaryViaPoint,
+                from_layer: preparedConnection.sourceLayer,
+                to_layer: targetLayer,
+                via_diameter: viaDiameter,
+                via_hole_diameter: viaHoleDiameter,
+              },
+              {
+                route_type: "wire",
+                ...boundaryViaPoint,
+                width: traceWidth,
+                layer: targetLayer,
+              },
+              {
+                route_type: "wire",
+                ...finalExitPoint,
+                width: traceWidth,
+                layer: targetLayer,
+              },
+            ],
+          },
+        },
+      ]
+      const boundaryViaPlansAreClear = fanoutPlansAreClear({
+        plans: [...acceptedPlans, ...plans],
+        srj,
+        sharedBoundary: bus.sharedBoundary,
+        clearance,
+        allowBlindAndBuriedVias,
+        allowSameNetMerges,
+      })
+      const reservedViasAreClear = reservedVias.every((reserved) => {
+        if (
+          reserved.connectionName === preparedConnection.connection.name ||
+          (allowSameNetMerges &&
+            connectionsShareElectricalNet(
+              srj,
+              reserved.connectionName,
+              preparedConnection.connection.name,
+            ))
+        )
+          return true
+        if (
+          via.spanLayers.some((layer) =>
+            reserved.via.spanLayers.includes(layer),
+          ) &&
+          distance(via.center, reserved.via.center) <
+            (via.diameter + reserved.via.diameter) / 2 + clearance - 1e-9
+        )
+          return false
+        return (
+          !reserved.via.spanLayers.includes(targetLayer) ||
+          distancePointToSegment(
+            reserved.via.center,
+            targetSegment.start,
+            targetSegment.end,
+          ) >=
+            reserved.via.diameter / 2 + traceWidth / 2 + clearance - 1e-9
+        )
+      })
+      if (boundaryViaPlansAreClear && reservedViasAreClear) {
+        addAlternative(plans)
+        return alternatives
+      }
+    }
+  }
+
   if (viaMinimalOnly) return alternatives
 
   const searchConnectionOrder = (

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

@@ -64,6 +64,12 @@ export interface RouteViaMinimalWindingParams {
   gridStepDivisor?: 1 | 2
   /** Bias bounded fixed-site searches toward the remote target band. */
   preferTargetDirectedLaneBias?: boolean
+  /** Internal path-only mode used before a boundary-side via is appended. */
+  allowSourceLayerRouting?: boolean
+  /** Promote a blocked terminal while staying within maximumRouteOrderAttempts. */
+  adaptiveRouteOrder?: boolean
+  /** Align a fine grid with pad/interstice centers instead of the boundary. */
+  alignGridToPads?: boolean
 }
 
 export interface RouteViaMinimalWindingProgress {
@@ -493,6 +499,7 @@ function buildPlan(params: {
     layer: connection.sourceLayer,
   }
   const hasSourceDogbone = distance(sourcePoint, terminal.viaPoint) > EPSILON
+  const changesLayer = connection.sourceLayer !== targetLayer
   const targetSegments = getSegments(targetLayerPoints, traceWidth, targetLayer)
   const spanLayers = getViaSpanLayers({
     fromLayer: connection.sourceLayer,
@@ -528,20 +535,24 @@ function buildPlan(params: {
           },
         ]
       : []),
-    {
-      route_type: "via",
-      ...terminal.viaPoint,
-      from_layer: connection.sourceLayer,
-      to_layer: targetLayer,
-      via_diameter: viaDiameter,
-      via_hole_diameter: viaHoleDiameter,
-    },
-    {
-      route_type: "wire",
-      ...terminal.viaPoint,
-      width: traceWidth,
-      layer: targetLayer,
-    },
+    ...(changesLayer
+      ? [
+          {
+            route_type: "via" as const,
+            ...terminal.viaPoint,
+            from_layer: connection.sourceLayer,
+            to_layer: targetLayer,
+            via_diameter: viaDiameter,
+            via_hole_diameter: viaHoleDiameter,
+          },
+          {
+            route_type: "wire" as const,
+            ...terminal.viaPoint,
+            width: traceWidth,
+            layer: targetLayer,
+          },
+        ]
+      : []),
     ...targetLayerPoints.slice(1).map((point) => ({
       route_type: "wire" as const,
       ...point,
@@ -589,7 +600,7 @@ function buildPlan(params: {
       route,
     },
     segments,
-    via,
+    via: changesLayer ? via : undefined,
     length: segments.reduce(
       (total, segment) => total + distance(segment.start, segment.end),
       0,
@@ -624,6 +635,9 @@ export function* routeViaMinimalWindingAlternativesSteps(
     reservedVias = [],
     gridStepDivisor = 1,
     preferTargetDirectedLaneBias = false,
+    allowSourceLayerRouting = false,
+    adaptiveRouteOrder = false,
+    alignGridToPads = false,
   } = params
   if (
     maximumRouteOrderAttempts !== undefined &&
@@ -643,18 +657,33 @@ export function* routeViaMinimalWindingAlternativesSteps(
   if (
     terminals.length === 0 ||
     !bus.exitEdge ||
-    terminals.some(
-      (terminal) => terminal.connection.sourceLayer === targetLayer,
-    )
+    (!allowSourceLayerRouting &&
+      terminals.some(
+        (terminal) => terminal.connection.sourceLayer === targetLayer,
+      ))
   ) {
     return []
   }
 
-  const gridStep = (traceWidth + clearance) / gridStepDivisor
+  const baseGridStep = (traceWidth + clearance) / gridStepDivisor
+  const pitch = Math.min(bus.pitchX, bus.pitchY)
+  const alignGridToPitch =
+    alignGridToPads && gridStepDivisor === 2 && Number.isFinite(pitch)
+  const gridStep = alignGridToPitch
+    ? pitch / (2 * Math.ceil(pitch / (2 * baseGridStep)))
+    : baseGridStep
   if (!Number.isFinite(gridStep) || gridStep <= 0) return []
   const { minX, maxX, minY, maxY } = bus.sharedBoundary
-  const columnCount = Math.floor((maxX - minX) / gridStep) + 1
-  const rowCount = Math.floor((maxY - minY) / gridStep) + 1
+  const originX = bus.xCoordinates[0] ?? minX
+  const originY = bus.yCoordinates[0] ?? minY
+  const gridMinX = alignGridToPitch
+    ? originX + Math.ceil((minX - originX) / gridStep) * gridStep
+    : minX
+  const gridMinY = alignGridToPitch
+    ? originY + Math.ceil((minY - originY) / gridStep) * gridStep
+    : minY
+  const columnCount = Math.floor((maxX - gridMinX) / gridStep) + 1
+  const rowCount = Math.floor((maxY - gridMinY) / gridStep) + 1
   const nodeCount = columnCount * rowCount
   if (columnCount < 2 || rowCount < 2 || nodeCount > MAX_GRID_NODE_COUNT) {
     return []
@@ -665,7 +694,7 @@ export function* routeViaMinimalWindingAlternativesSteps(
     return {
       column,
       row,
-      point: { x: minX + column * gridStep, y: minY + row * gridStep },
+      point: { x: gridMinX + column * gridStep, y: gridMinY + row * gridStep },
     }
   })
   const sampledGridPoints = includeVisualization
@@ -797,6 +826,18 @@ export function* routeViaMinimalWindingAlternativesSteps(
     }
     for (const blocker of acceptedAttemptSegments) {
       if (sharesNet(connectionName, blocker.connectionName)) continue
+      const margin = (segment.width + blocker.segment.width) / 2 + clearance
+      if (
+        Math.max(segment.start.x, segment.end.x) + margin <
+          Math.min(blocker.segment.start.x, blocker.segment.end.x) ||
+        Math.min(segment.start.x, segment.end.x) - margin >
+          Math.max(blocker.segment.start.x, blocker.segment.end.x) ||
+        Math.max(segment.start.y, segment.end.y) + margin <
+          Math.min(blocker.segment.start.y, blocker.segment.end.y) ||
+        Math.min(segment.start.y, segment.end.y) - margin >
+          Math.max(blocker.segment.start.y, blocker.segment.end.y)
+      )
+        continue
       if (
         distanceSegmentToSegment(
           segment.start,
@@ -1283,6 +1324,9 @@ export function* routeViaMinimalWindingAlternativesSteps(
   const initialRouteOrderFactories: Array<
     () => readonly ViaMinimalWindingTerminal[]
   > = []
+  if (alignGridToPads && preferTargetDirectedLaneBias && viasAreBeforeTargets) {
+    initialRouteOrderFactories.push(() => targetOrderedTerminals)
+  }
   if (viasAreBeforeTargets) {
     initialRouteOrderFactories.push(() => [
       ...targetOrderedTerminals.slice(1),
@@ -1340,11 +1384,28 @@ export function* routeViaMinimalWindingAlternativesSteps(
     getItemKey: (terminal) => terminal.connection.connection.name,
     maximumOrderCount: maximumRouteOrderCount,
   })
+  const pendingRouteOrders: ViaMinimalWindingTerminal[][] = []
+  const seenAdaptiveOrders = new Set<string>()
+  const adaptiveRouteOrders = function* () {
+    while (true) {
+      const pending = pendingRouteOrders.shift()
+      const next = pending
+        ? { done: false, value: pending }
+        : routeOrders.next()
+      if (next.done) return
+      const key = next.value
+        .map((terminal) => terminal.connection.connection.name)
+        .join("|")
+      if (seenAdaptiveOrders.has(key)) continue
+      seenAdaptiveOrders.add(key)
+      yield next.value
+    }
+  }
 
   const alternatives: FanoutRoutePlan[][] = []
   const seenAlternativeKeys = new Set<string>()
   let routeOrderAttemptCount = 0
-  for (const routeOrder of routeOrders) {
+  for (const routeOrder of adaptiveRouteOrders()) {
     for (const laneBias of laneBiases) {
       if (
         maximumRouteOrderAttempts !== undefined &&
@@ -1415,6 +1476,16 @@ export function* routeViaMinimalWindingAlternativesSteps(
             : {}),
         }
         if (!points) {
+          if (
+            adaptiveRouteOrder &&
+            maximumRouteOrderAttempts !== undefined &&
+            terminalIndex > 0
+          ) {
+            const others = routeOrder.filter(
+              (candidate) => candidate !== terminal,
+            )
+            pendingRouteOrders.push([terminal, ...others])
+          }
           failed = true
           break
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fanout-solver",
-  "version": "0.0.50",
+  "version": "0.0.52",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",
@@ -32,7 +32,7 @@
     "test": "bun test",
     "benchmark": "bun benchmarks/run-benchmark.ts",
     "generate:repro04": "bun scripts/generate-repro/generate-repro04.tsx",
-    "benchmark:srj29": "./benchmark.sh",
+    "benchmark:srj29": "bun benchmarks/run-srj29-benchmark.ts",
     "render:dataset": "bun scripts/render-dataset-pngs.ts",
     "format": "biome format --write .",
     "format:check": "biome format ."