@tscircuit/fanout-solver 0.0.52 → 0.0.54

package/README.md

@@ -16,7 +16,7 @@ and treats each bus-layer decision atomically.
 - Detects rectangular pad footprints through obstacle `componentId` metadata,
   including perimeter packages and two-pad passives.
 - Handles multiple mixed footprints inside one shared breakout boundary.
-- Routes perimeter and inner-matrix pads; the benchmark connects every pad.
+- Routes perimeter and inner-matrix pads.
 - Uses `sharedBoundary` as the common exit rectangle. Without one, it infers a
   shared rectangle around the source footprints selected for the buses, without
   expanding that boundary to include destination footprints.
@@ -280,20 +280,32 @@ 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
+## Dataset 31 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.
+Run `./benchmark.sh` (or `bun run benchmark`) to benchmark **only the 12 AM62L
+directional cases** from
+[`tscircuit/dataset-fanout31-am62l`](https://github.com/tscircuit/dataset-fanout31-am62l).
+The upstream revision is pinned in `scripts/generate-repro/package.json` and
+recorded in every report. Other datasets remain available for regression tests
+and the debugger, but have no benchmark commands or workflows.
 
 ```sh
 ./benchmark.sh
 ./benchmark.sh --list
-./benchmark.sh --dataset dataset08
-./benchmark.sh --dataset srj19,srj29 --sample sample001
+./benchmark.sh --sample 11-left-center
 ./benchmark.sh --concurrency 8 --sample-timeout-seconds 300
 ```
 
+Before timing the solver, the benchmark renders the selected upstream TSX/core
+circuits and captures their exact fanout-solver constructor inputs into
+`benchmark-results/inputs/<sample-id>.json`. Each case retains all 135 AM62L
+connections, 573 pad obstacles, nine DDR buses, 102 plane drops, and the original
+clearance, differential-pair, and length-skew constraints. The timed workers run
+**this checkout's solver**, not the upstream package's released solver.
+To capture the inputs without solving, use `bun run generate:dataset31`.
+The optional `--dataset dataset31` flag is accepted for explicit CI invocation;
+other dataset selections are rejected.
+
 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.
@@ -301,80 +313,33 @@ 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.
+the solver commit, dataset revision, configuration, solve totals, every sample's
+status and timing, and partial routing/validation counts. Reports are saved after
+every completed sample, including the total selected count to identify incomplete runs.
 Timed-out workers do not retain their in-flight routing counts.
 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).
+AM62L fanout, not RAM fanout or downstream inter-chip routing. Partial, error,
+and timeout rows are benchmark results (exit 0); invalid CLI arguments or report
+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.
+PR's exact head SHA, runs all 12 dataset 31 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 reports and captured inputs. 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
-[`tscircuit/dataset-srj29-bga-decoupling`](https://github.com/tscircuit/dataset-srj29-bga-decoupling)
-as a pinned development dependency. The adapter keeps the complete obstacle
-field, including opposite-layer capacitor pads and bodies. VCC and GND are
-grouped onto opposite boundary corridors, while the capacitor pad remains the
-downstream endpoint of every power connection; a local capacitor or plane via
-alone cannot count as a solved BGA pin. Remaining edge signals are grouped by
-direction. Every adapted problem uses the same six-layer stackup (`top`,
-`inner1` through `inner4`, and `bottom`) so benchmark improvements are directly
-comparable.
-
-The dedicated legacy SRJ29 report remains available with:
-
-```sh
-bun run benchmark:srj29
-```
-
-Use `--sample sample001`, `--limit 10`, or
-`--max-layer-combinations 16` for shorter runs. Samples run one at a time by
-default and print progress as they finish. `--concurrency 8` runs isolated
-samples in parallel, and `--sample-timeout-seconds 600` prevents a difficult
-sample from blocking the remaining work. Each run writes the full ordered
-results to `benchmark-results/srj29.json` and
-`benchmark-results/srj29.md`. A row is marked solved only when every input
-connection has a validated breakout and an independent physical-copper audit
-proves that the emitted wires, vias, and same-net pads connect every original
-endpoint on compatible layers. A second independent audit checks every emitted
-trace and via against different-net pads, obstacles, traces, and vias on every
-physical layer in its span. Reaching an arbitrary boundary point, retaining an
-unrouted endpoint in the output JSON, or emitting copper with a DRC violation
-does not count. The report separates fanout-prefix completion from physically
-connected original connections so partial progress remains visible without
-overstating it as a solution. Partial solutions are reported as benchmark
-results instead of failing the command. `bun run benchmark:srj29` is an alias
-for the same command.
-
-The `SRJ29 Benchmark` GitHub Actions workflow runs the complete dataset on a
-Blacksmith 32-vCPU ARM runner with 32 sample processes by default. It can be
-started manually with an optional sample id, or for a pull request by adding
-`[BENCHMARK TEST]` to its title. The workflow publishes the Markdown summary and
-uploads both reports as an artifact.
-
-Run `bun run start` and inspect the SRJ29 fixtures to step through the selected
-sample. The derivative dataset also publishes dedicated Cosmos pages for the
-first ten samples.
+PR code. The trusted renderer rejects legacy or mixed-dataset reports, so PR
+comments contain only dataset 31 results. Only exact commands from non-bot users
+with current write, maintain, or admin access are accepted.
 
 ## Dataset 02
 
@@ -527,8 +492,8 @@ bun run render:dataset
 bun run start
 ```
 
-The benchmark runs every sample in all datasets and reports footprint, pad,
-connection, routing, and layer-assignment metrics. `bun run start` opens the
+The benchmark runs only the 12 dataset 31 AM62L cases and reports solve counts,
+validation, and timing. `bun run start` opens all regression
 datasets in the standard tscircuit solver debugger. `bun run
 render:dataset` writes `graphics-debug` PNGs under one subdirectory per dataset,
 with a red shared boundary, gray component courtyards, and green fanout-exit

package/lib/fanout-solver.ts

@@ -1,5 +1,6 @@
 import type { SimpleRouteJson } from "@tscircuit/capacity-autorouter"
 import { BaseSolver } from "@tscircuit/solver-utils"
+import { shortenBusPlans } from "./shorten-bus-plans"
 import { type GraphicsObject, mergeGraphics } from "graphics-debug"
 import { addViaLayerMetadataToSrj } from "./add-via-layer-metadata"
 import { getCornerBandSide, getExitEdgeForDirection } from "./boundary-exit"
@@ -1380,8 +1381,12 @@ export class FanoutSolver extends BaseSolver {
   private *routeDenseThroughAllMixedTerminationSteps(params: {
     busLayerAssignments: Readonly<Record<string, string>>
     busesInRoutingOrder: readonly PreparedBus[]
+    denseRoutingStrategy?: "pad-aligned" | "boundary-aligned"
+    lengthMatchingStage?: "before-planes" | "after-planes"
   }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
     if (this.config.allowBlindAndBuriedVias) return null
+    const usePadAlignedDenseRouting =
+      params.denseRoutingStrategy !== "boundary-aligned"
     const debugDense = (...values: unknown[]) => {
       if (process.env.FANOUT_DEBUG_DENSE === "1") {
         if (
@@ -1414,6 +1419,9 @@ export class FanoutSolver extends BaseSolver {
     const useConfiguredDensePlaneRouting =
       this.config.densePlaneReservationBusIds.length > 0 ||
       this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0
+    const matchLengthsAfterPlanes =
+      useConfiguredDensePlaneRouting &&
+      params.lengthMatchingStage !== "before-planes"
     const useJointBoundaryViaReservation = shouldUseJointBoundaryViaReservation(
       unsortedBoundaryBuses.map((bus) => bus.connections.length),
     )
@@ -1902,6 +1910,7 @@ export class FanoutSolver extends BaseSolver {
       ...singletonDeferralCandidates.filter((bus) => {
         const containingBus = getContainingWideSourceField(bus)
         const sharesContainingBusLayer =
+          usePadAlignedDenseRouting &&
           !useConfiguredDensePlaneRouting &&
           containingBus &&
           params.busLayerAssignments[containingBus.busId] ===
@@ -2160,9 +2169,11 @@ export class FanoutSolver extends BaseSolver {
           fixedViaPointsByConnectionIndex,
           reservedVias: getReservedVias(bus),
           viaMinimalOnly: process.env.FANOUT_DEBUG_ALLOW_EXTRA_VIAS !== "1",
-          allowBoundarySideViaFallback: !useConfiguredDensePlaneRouting,
+          allowBoundarySideViaFallback: true,
+          preferCornerBoundaryVia: useConfiguredDensePlaneRouting,
           adaptiveWindingRouteOrder,
-          alignWindingGridToPads: !useConfiguredDensePlaneRouting,
+          alignWindingGridToPads:
+            usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting,
           fixedViaFallbackRouteOrderAttempts: adaptiveWindingRouteOrder
             ? 60
             : useConfiguredDensePlaneRouting
@@ -2218,7 +2229,7 @@ export class FanoutSolver extends BaseSolver {
         if (!busPlans && preferSingleLayerWinding) {
           busPlans = (yield* routeAlternatives(routeParams, 1))[0]
         }
-        if (!busPlans && !useConfiguredDensePlaneRouting) {
+        if (!busPlans) {
           const originalPoints = fixedViaPointsByConnectionIndex
           const originalOutward =
             preferBoundaryOutwardByBusId.get(bus.busId) ?? true
@@ -2292,6 +2303,7 @@ export class FanoutSolver extends BaseSolver {
                 ...routeParams,
                 fixedViaPointsByConnectionIndex: rematchedPoints,
                 reservedVias: getReservedVias(bus),
+                alignWindingGridToPads: useConfiguredDensePlaneRouting,
                 fixedViaFallbackRouteOrderAttempts: 3,
               },
               1,
@@ -2313,7 +2325,7 @@ 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) {
+          if (needsRouteDiversity && !matchLengthsAfterPlanes) {
             busPlans = (yield* routeAlternatives(routeParams, 3)).toSorted(
               (first, second) => {
                 const firstLengths = first.map((plan) => plan.length)
@@ -2630,6 +2642,7 @@ export class FanoutSolver extends BaseSolver {
         let feasibleAlternatePlanePlans: FanoutRoutePlan[] = []
         const matchViaPointsAroundPlans = (
           candidatePlans: readonly FanoutRoutePlan[],
+          promotedAlternatePlaneBusIds: ReadonlySet<string> = new Set(),
         ): Map<number, { x: number; y: number }> | null => {
           feasibleAlternatePlanePlans = []
           const fixedBoundaryViaPoints = new Map(
@@ -2645,10 +2658,18 @@ export class FanoutSolver extends BaseSolver {
               segment,
             })),
           )
-          const boundaryBusesToMatch = useConfiguredDensePlaneRouting
+          const preserveBoundaryCopper =
+            !useConfiguredDensePlaneRouting ||
+            candidatePlans.some(
+              (plan) =>
+                plan.segments.filter(
+                  (segment) => segment.layer === plan.sourceLayer,
+                ).length > 1,
+            )
+          const boundaryBusesToMatch = !preserveBoundaryCopper
             ? boundaryBuses
             : []
-          const blockingVias = useConfiguredDensePlaneRouting
+          const blockingVias = !preserveBoundaryCopper
             ? []
             : candidatePlans.flatMap((plan) =>
                 [
@@ -2667,7 +2688,7 @@ export class FanoutSolver extends BaseSolver {
           // 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
+          const retainedViaPoints = !preserveBoundaryCopper
             ? null
             : matchComponentDogboneViaSites(planeBuses, {
                 viaDiameter: this.config.viaDiameter,
@@ -2775,6 +2796,7 @@ export class FanoutSolver extends BaseSolver {
                   )
                 : []
             const additionalAlternatePlaneBusIds = new Set([
+              ...promotedAlternatePlaneBusIds,
               ...this.config.denseUnrestrictedPlaneRoutingBusIds,
               ...(process.env.FANOUT_DEBUG_ADDITIONAL_ALTERNATE_PLANE_BUS_IDS?.split(
                 ",",
@@ -3345,7 +3367,16 @@ export class FanoutSolver extends BaseSolver {
                 )[0]
                 if (!promotedPlans) {
                   debugDense("plane-route:promote-failed", planeBus.busId)
-                  return null
+                  // Let these newly blocked drops participate in the joint
+                  // choice. Each retry adds previously excluded plane buses,
+                  // so the recursion is bounded by the number of plane buses.
+                  return matchViaPointsAroundPlans(
+                    candidatePlans,
+                    new Set([
+                      ...promotedAlternatePlaneBusIds,
+                      ...zeroCandidatePlaneBuses.map((bus) => bus.busId),
+                    ]),
+                  )
                 }
                 feasibleAlternatePlanePlans.push(...promotedPlans)
               }
@@ -3466,22 +3497,25 @@ export class FanoutSolver extends BaseSolver {
             : null
         }
         debugDense("length-match:start", matchedPlans.length)
-        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
-          },
-        })
+        const matchedLengthResult = matchLengthsAfterPlanes
+          ? { plans: matchedPlans }
+          : 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
+              },
+            })
         debugDense(
           "length-match:complete",
           matchedLengthResult.plans?.length ?? "failed",
@@ -3565,6 +3599,65 @@ export class FanoutSolver extends BaseSolver {
           yield
         }
       }
+      if (matchedRoutingSucceeded && matchLengthsAfterPlanes) {
+        // With the configured plane escape strategy, route those dogbones
+        // before tuning. Length matching can then check the actual complete
+        // copper instead of repeatedly searching for a new plane assignment
+        // for every prospective meander.
+        const lengthMatchingParams = {
+          plans: matchedPlans,
+          preparedBuses: this.preparedBuses,
+          inputSrj: this.inputSrj,
+          sharedBoundary: this.getValidationBoundary(),
+          clearance: this.config.clearance,
+          allowBlindAndBuriedVias: false,
+          allowSameNetMerges: this.config.allowSameNetMerges,
+          allowMatchingInsideDenseBounds: true,
+          allowPairLaneSpreading: true,
+        }
+        let matchedLengthResult = matchBusPlanLengths(lengthMatchingParams)
+        const shortenedBusIds = new Set<string>()
+        while (
+          !matchedLengthResult.plans &&
+          matchedLengthResult.failedBus &&
+          !shortenedBusIds.has(matchedLengthResult.failedBus.busId)
+        ) {
+          const bus = matchedLengthResult.failedBus
+          shortenedBusIds.add(bus.busId)
+          const shortened = shortenBusPlans({
+            plans: matchedPlans,
+            bus,
+            srj: this.inputSrj,
+            sharedBoundary: this.getValidationBoundary(),
+            layerNames: this.config.layerNames,
+            traceWidth: this.config.traceWidth,
+            viaDiameter: this.config.viaDiameter,
+            viaHoleDiameter: this.config.viaHoleDiameter,
+            clearance: this.config.clearance,
+            allowSameNetMerges: this.config.allowSameNetMerges,
+          })
+          if (shortened.every((plan, index) => plan === matchedPlans[index]))
+            break
+          matchedPlans = shortened
+          matchedLengthResult = matchBusPlanLengths({
+            ...lengthMatchingParams,
+            plans: matchedPlans,
+          })
+        }
+        if (matchedLengthResult.plans) {
+          matchedPlans = matchedLengthResult.plans
+        } else {
+          matchedRoutingSucceeded = false
+        }
+        this.setInProgressPlans({
+          phase: "match-dense-complete-lengths",
+          plans: matchedPlans,
+          strategy: "default",
+          unitIndex: ++denseWorkUnitIndex,
+          unitCount: denseWorkUnitCount,
+        })
+        yield
+      }
       const densePlansAreClear =
         matchedRoutingSucceeded &&
         fanoutPlansAreClear({
@@ -3586,7 +3679,30 @@ export class FanoutSolver extends BaseSolver {
       }
     }
 
-    if (process.env.FANOUT_DEBUG_DENSE_ONLY === "1") return null
+    if (matchLengthsAfterPlanes) {
+      return yield* this.routeDenseThroughAllMixedTerminationSteps({
+        ...params,
+        lengthMatchingStage: "before-planes",
+      })
+    }
+
+    // Pad-aligned windings can fence off a same-layer singleton even when
+    // every wide bus routes successfully. Before widening the search, retry
+    // the coordinated reservation with a boundary-aligned grid and let those
+    // singleton sites remain provisional until surrounding copper is fixed.
+    if (usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting) {
+      const boundaryAlignedState =
+        yield* this.routeDenseThroughAllMixedTerminationSteps({
+          ...params,
+          denseRoutingStrategy: "boundary-aligned",
+        })
+      if (boundaryAlignedState) return boundaryAlignedState
+    }
+    if (
+      !usePadAlignedDenseRouting ||
+      process.env.FANOUT_DEBUG_DENSE_ONLY === "1"
+    )
+      return null
 
     const maximumStates = 8
     const getBoundaryStates = (

package/lib/match-bus-lengths.ts

@@ -565,6 +565,67 @@ function getBusSkew(plans: readonly FanoutRoutePlan[]): number {
   return Math.max(...lengths) - Math.min(...lengths)
 }
 
+function* createSpreadLaneCandidates(
+  plan: FanoutRoutePlan,
+  clearance: number,
+): Generator<FanoutRoutePlan> {
+  for (const { segment, index } of plan.segments
+    .map((segment, index) => ({ segment, index }))
+    .filter(({ segment }) => segment.layer === plan.targetLayer)
+    .toSorted(
+      (a, b) =>
+        distance(b.segment.start, b.segment.end) -
+        distance(a.segment.start, a.segment.end),
+    )) {
+    const length = distance(segment.start, segment.end)
+    if (length <= EPSILON) continue
+    const dx = Math.abs(segment.end.x - segment.start.x)
+    const dy = Math.abs(segment.end.y - segment.start.y)
+    if (dx > EPSILON && dy > EPSILON && Math.abs(dx - dy) > EPSILON) continue
+    const tangent = {
+      x: (segment.end.x - segment.start.x) / length,
+      y: (segment.end.y - segment.start.y) / length,
+    }
+    const pitch = segment.width + clearance
+    for (const multiple of [2, 3, 4, 6]) {
+      const offset = pitch * multiple
+      if (length < 2 * offset + pitch) continue
+      for (const sign of [1, -1]) {
+        const normal = { x: -tangent.y * sign, y: tangent.x * sign }
+        const points = [
+          segment.start,
+          addScaled(addScaled(segment.start, tangent, offset), normal, offset),
+          addScaled(addScaled(segment.end, tangent, -offset), normal, offset),
+          segment.end,
+        ]
+        const replacement = points.slice(1).map((end, i) => ({
+          ...segment,
+          start: points[i]!,
+          end,
+        }))
+        const segments = [
+          ...plan.segments.slice(0, index),
+          ...replacement,
+          ...plan.segments.slice(index + 1),
+        ]
+        if (hasNonAdjacentSelfIntersection(segments)) continue
+        if (
+          !replacementCopperIsSelfClear({
+            plan,
+            segments,
+            replacementStartIndex: index,
+            replacementSegmentCount: replacement.length,
+            clearance,
+          })
+        )
+          continue
+        const candidate = createPlanWithSegments(plan, segments)
+        if (candidate) yield candidate
+      }
+    }
+  }
+}
+
 /**
  * Adds straight/45-degree meanders after the dense component escape. Matching
  * is atomic: a constrained bus either satisfies its declared skew with the
@@ -584,6 +645,8 @@ export function matchBusPlanLengths(params: {
    * revalidated and whose remaining dogbone capacity is checked atomically.
    */
   allowMatchingInsideDenseBounds?: boolean
+  /** Allow a differential pair's longer lane to move aside before tuning its mate. */
+  allowPairLaneSpreading?: boolean
   /**
    * Rejects a geometrically clear candidate when it would make a caller-owned
    * downstream assignment (such as pending plane dogbones) infeasible.
@@ -760,6 +823,49 @@ export function matchBusPlanLengths(params: {
         }
         if (acceptedPlans) break
       }
+      if (
+        !acceptedPlans &&
+        params.allowPairLaneSpreading &&
+        bus.connections.length === 2
+      ) {
+        // A tightly packed pair may leave no space to lengthen the inner lane.
+        // Move the outer lane, then retune the complete pair atomically. Only
+        // four geometrically clear placements may start another matching pass.
+        const longer = busPlans.find((plan) => plan !== shortest)!
+        let attempts = 0
+        for (const candidate of createSpreadLaneCandidates(longer, clearance)) {
+          const nextPlans = matchedPlans.map((plan) =>
+            plan === longer ? candidate : plan,
+          )
+          if (
+            !fanoutPlansAreClear({
+              plans: nextPlans,
+              srj: inputSrj,
+              sharedBoundary,
+              clearance,
+              allowBlindAndBuriedVias,
+              allowSameNetMerges,
+            })
+          )
+            continue
+          if (
+            candidatePlansAreFeasible &&
+            !candidatePlansAreFeasible(nextPlans)
+          )
+            continue
+          const result = matchBusPlanLengths({
+            ...params,
+            plans: nextPlans,
+            preparedBuses: [bus],
+            allowPairLaneSpreading: false,
+          })
+          if (result.plans) {
+            acceptedPlans = result.plans
+            break
+          }
+          if (++attempts >= 4) break
+        }
+      }
       if (!acceptedPlans) return { plans: null, failedBus: bus }
       matchedPlans = acceptedPlans
     }

package/lib/route-bus.ts

@@ -64,6 +64,8 @@ export interface RouteBusParams {
   viaMinimalOnly?: boolean
   /** Permit a singleton to move its provisional via near the boundary. */
   allowBoundarySideViaFallback?: boolean
+  /** Reserve corner tuning space when selecting a boundary-side via. */
+  preferCornerBoundaryVia?: boolean
   /** Retry blocked winding terminals ahead of already-routed terminals. */
   adaptiveWindingRouteOrder?: boolean
   /** Preserve pad-lattice channels in the automatic dense routing path. */
@@ -1611,8 +1613,10 @@ function segmentIsClearOfObstacles(params: {
     ) {
       continue
     }
+    // A winding escape can turn more than once while leaving its own pad.
     if (
-      segmentIndex === 0 &&
+      segmentIndex >= 0 &&
+      segmentIndex < (plan.sourceEscapeSegmentCount ?? 1) &&
       obstacle === plan.sourceObstacle &&
       segment.layer === plan.sourceLayer
     ) {
@@ -2003,7 +2007,9 @@ export function fanoutPlansAreClear(params: {
 }
 
 function routePlaneTerminatedBus(
-  params: RouteBusParams,
+  params: RouteBusParams & {
+    collectAlternative?: (plan: FanoutRoutePlan) => boolean
+  },
 ): FanoutRoutePlan[] | null {
   const {
     srj,
@@ -2037,6 +2043,8 @@ function routePlaneTerminatedBus(
         remainingPlaneCandidatesToSkip--
         continue
       }
+      if (params.collectAlternative && !params.collectAlternative(plan))
+        continue
       return plan
     }
     return undefined
@@ -2452,6 +2460,7 @@ export function* routeBusAlternativesSteps(
     reservedVias = [],
     viaMinimalOnly = false,
     allowBoundarySideViaFallback = false,
+    preferCornerBoundaryVia = false,
     adaptiveWindingRouteOrder = false,
     alignWindingGridToPads = false,
     fixedViaFallbackRouteOrderAttempts = 24,
@@ -2473,6 +2482,19 @@ export function* routeBusAlternativesSteps(
   }
   if (bus.termination.type === "plane") {
     const alternatives: FanoutRoutePlan[][] = []
+    if (bus.connections.length === 1 && maxAlternatives > 1) {
+      // Enumerate once instead of rebuilding and skipping every earlier route
+      // for each successive alternative. Keep the original candidate order.
+      routePlaneTerminatedBus({
+        ...params,
+        planeCandidateSkipCount: 0,
+        collectAlternative: (plan) => {
+          alternatives.push([plan])
+          return alternatives.length >= maxAlternatives
+        },
+      })
+      return alternatives
+    }
     for (
       let planeCandidateSkipCount = 0;
       planeCandidateSkipCount < maxAlternatives;
@@ -2801,14 +2823,19 @@ export function* routeBusAlternativesSteps(
       acceptedBoundaryPlansExist && !allowBlindAndBuriedVias
         ? [...mixedDogboneTerminalPatterns, ...uniformDogboneTerminalPatterns]
         : [...uniformDogboneTerminalPatterns, ...mixedDogboneTerminalPatterns]
+    const unreservedTerminalPatterns: CoordinatedTerminalPattern[] =
+      canUseViaInPadTerminals
+        ? planeTerminationsAlreadyOccupyTheFanout
+          ? [viaInPadTerminalPattern, ...dogboneTerminalPatterns]
+          : [...dogboneTerminalPatterns, viaInPadTerminalPattern]
+        : dogboneTerminalPatterns
+    // Automatically matched sites are candidates, not caller reservations.
+    // Keep the ordinary dogbone patterns available before adding crossover
+    // vias when that first site assignment cannot route the complete bus.
     const terminalPatterns: CoordinatedTerminalPattern[] =
-      fixedViaTerminalPatterns.length > 0
+      fixedViaPointsByConnectionIndex
         ? fixedViaTerminalPatterns
-        : canUseViaInPadTerminals
-          ? planeTerminationsAlreadyOccupyTheFanout
-            ? [viaInPadTerminalPattern, ...dogboneTerminalPatterns]
-            : [...dogboneTerminalPatterns, viaInPadTerminalPattern]
-          : dogboneTerminalPatterns
+        : [...fixedViaTerminalPatterns, ...unreservedTerminalPatterns]
     const seenTerminalSignatures = new Set<string>()
     for (const terminalPattern of terminalPatterns) {
       const terminals = bus.connections.map((preparedConnection) => {
@@ -2857,12 +2884,24 @@ export function* routeBusAlternativesSteps(
           ),
         }
       })
+      const alignGridToPads =
+        alignWindingGridToPads ||
+        Boolean(terminalPattern.getViaPoint && !fixedViaPointsByConnectionIndex)
+      const gridStepDivisor =
+        terminalPattern.getViaPoint &&
+        Math.min(bus.pitchX, bus.pitchY) -
+          2 * (viaDiameter / 2 + traceWidth / 2 + clearance) <
+          traceWidth + clearance
+          ? 2
+          : 1
       const terminalSignature = `${terminals
         .map(
           (terminal) =>
             `${terminal.connection.connectionIndex}:${terminal.viaPoint.x}:${terminal.viaPoint.y}:${terminal.exitPoint.x}:${terminal.exitPoint.y}`,
         )
-        .join("|")}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}`
+        .join(
+          "|",
+        )}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}:${gridStepDivisor}:${alignGridToPads}`
       if (seenTerminalSignatures.has(terminalSignature)) continue
       seenTerminalSignatures.add(terminalSignature)
       const windingSteps = routeViaMinimalWindingAlternativesSteps(
@@ -2881,17 +2920,9 @@ export function* routeBusAlternativesSteps(
           allowSameNetMerges,
           maximumRouteOrderAttempts: terminalPattern.maximumRouteOrderAttempts,
           adaptiveRouteOrder: adaptiveWindingRouteOrder,
-          alignGridToPads:
-            alignWindingGridToPads ||
-            Boolean(coordinatedViaPoints && !fixedViaPointsByConnectionIndex),
+          alignGridToPads,
           reservedVias,
-          gridStepDivisor:
-            coordinatedViaPoints &&
-            Math.min(bus.pitchX, bus.pitchY) -
-              2 * (viaDiameter / 2 + traceWidth / 2 + clearance) <
-              traceWidth + clearance
-              ? 2
-              : 1,
+          gridStepDivisor,
           preferTargetDirectedLaneBias:
             terminalPattern.preferTargetDirectedLaneBias,
         },
@@ -2962,11 +2993,24 @@ export function* routeBusAlternativesSteps(
     const preparedConnection = bus.connections[0]!
     const boundaryDirection = getDirectionForExitEdge(bus.exitEdge)
     const boundaryExitAxis = getExitAxis(bus, boundaryDirection)
-    const finalTrack = getBoundaryTargetTrack({
-      bus,
-      connection: preparedConnection,
-      boundaryDirection,
-    })
+    const finalTrack =
+      preferCornerBoundaryVia && getCornerSide(bus)
+        ? getCornerTargetTrack({
+            bus,
+            connection: preparedConnection,
+            cornerExitLaneOffset: cornerLaneOffsets.exit,
+            traceWidth,
+            viaDiameter,
+            clearance,
+            layerNames,
+            targetLayer,
+            cornerBandTargetTrackOffset,
+          })
+        : getBoundaryTargetTrack({
+            bus,
+            connection: preparedConnection,
+            boundaryDirection,
+          })
     const finalExitPoint = makePoint(
       boundaryExitAxis,
       finalTrack,
@@ -2992,13 +3036,27 @@ export function* routeBusAlternativesSteps(
       viaDiameter / 2 + clearance,
       Math.min(bus.pitchX, bus.pitchY) / 2,
     )
-    for (const multiple of [1, 2, 3, 4, 5]) {
+    const cornerSide = preferCornerBoundaryVia ? getCornerSide(bus) : undefined
+    const boundaryViaCandidates = [1, 2, 3, 4, 5].flatMap((multiple) => {
       const inset = multiple * insetStep
-      const boundaryViaPoint = makePoint(
+      const straight = makePoint(
         boundaryExitAxis - directionSign(boundaryDirection) * inset,
         finalTrack,
         boundaryDirection,
       )
+      if (!cornerSide) return [straight]
+      // Approach corner exits diagonally to leave the adjacent pair's tuning
+      // lane free of the through-via barrel. Retain the straight fallback.
+      return [
+        makePoint(
+          boundaryExitAxis - directionSign(boundaryDirection) * inset,
+          finalTrack + (cornerSide === "maximum" ? inset : -inset),
+          boundaryDirection,
+        ),
+        straight,
+      ]
+    })
+    for (const boundaryViaPoint of boundaryViaCandidates) {
       const sourceLayerSteps = routeViaMinimalWindingAlternativesSteps(
         {
           srj: sourceLayerSrj,
@@ -3065,6 +3123,9 @@ export function* routeBusAlternativesSteps(
       const plans: FanoutRoutePlan[] = [
         {
           ...sourceLayerPlan,
+          ...(preferCornerBoundaryVia
+            ? { sourceEscapeSegmentCount: sourceLayerPlan.segments.length }
+            : {}),
           targetLayer,
           exitPoint: finalExitPoint,
           via,

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

@@ -1075,6 +1075,10 @@ export function* routeViaMinimalWindingAlternativesSteps(
       endByNode.set(end.nodeIndex, values)
     }
     const stateCount = nodeCount * 9
+    // A* visits a grid edge with several incoming directions. Copper does not
+    // change while routing this terminal, so check each edge only once. Keep
+    // this cache local: later terminals and route-order attempts add blockers.
+    const edgeClearance = new Uint8Array(nodeCount * 8)
     const distances = new Float64Array(stateCount).fill(
       Number.POSITIVE_INFINITY,
     )
@@ -1205,21 +1209,6 @@ export function* routeViaMinimalWindingAlternativesSteps(
         }
         const nextNode = row * columnCount + column
         const nextPoint = nodes[nextNode]!.point
-        const segment: RoutedSegment = {
-          start: node.point,
-          end: nextPoint,
-          width: traceWidth,
-          layer: targetLayer,
-        }
-        if (
-          !segmentIsClear({
-            segment,
-            terminal,
-            acceptedAttemptSegments,
-          })
-        ) {
-          continue
-        }
         const addsTurn =
           current.direction !== 8 && current.direction !== directionIndex
         const nextTrack = getPerpendicularAxis(nextPoint, boundaryDirection)
@@ -1242,6 +1231,24 @@ export function* routeViaMinimalWindingAlternativesSteps(
           lanePenalty
         const nextState = nextNode * 9 + directionIndex
         if (nextDistance >= distances[nextState]! - EPSILON) continue
+        const edgeIndex = current.node * 8 + directionIndex
+        if (edgeClearance[edgeIndex] === 0) {
+          const clear = segmentIsClear({
+            segment: {
+              start: node.point,
+              end: nextPoint,
+              width: traceWidth,
+              layer: targetLayer,
+            },
+            terminal,
+            acceptedAttemptSegments,
+          })
+          edgeClearance[edgeIndex] = clear ? 1 : 2
+          edgeClearance[nextNode * 8 + ((directionIndex + 4) % 8)] = clear
+            ? 1
+            : 2
+        }
+        if (edgeClearance[edgeIndex] === 2) continue
         distances[nextState] = nextDistance
         previous[nextState] = state
         const remaining = heuristic(nextPoint)

package/lib/shorten-bus-plans.ts

@@ -0,0 +1,75 @@
+import type { SimpleRouteJson } from "@tscircuit/capacity-autorouter"
+import { fanoutPlansAreClear } from "./route-bus"
+import { routeViaMinimalWinding } from "./route-via-minimal-winding"
+import type { Bounds, FanoutRoutePlan, PreparedBus } from "./types"
+
+/** Revisit excessive winding detours after provisional reservations are gone. */
+export function shortenBusPlans(params: {
+  plans: readonly FanoutRoutePlan[]
+  bus: PreparedBus
+  srj: SimpleRouteJson
+  sharedBoundary: Bounds
+  layerNames: string[]
+  traceWidth: number
+  viaDiameter: number
+  viaHoleDiameter: number
+  clearance: number
+  allowSameNetMerges: boolean
+}): FanoutRoutePlan[] {
+  const { bus } = params
+  let plans = [...params.plans]
+  if (bus.maxLengthSkew === undefined) return plans
+  const busPlans = plans
+    .filter((plan) => plan.busId === bus.busId)
+    .toSorted((first, second) => second.length - first.length)
+  for (const plan of busPlans) {
+    const minimumLength = Math.min(
+      ...plans.filter((p) => p.busId === bus.busId).map((p) => p.length),
+    )
+    if (plan.length - minimumLength <= bus.maxLengthSkew) continue
+    // Retain the original source dogbone, through-via and boundary endpoint.
+    if (
+      !plan.via ||
+      plan.additionalVias?.length ||
+      plan.planeEndpointVia ||
+      plan.segments.filter((segment) => segment.layer === plan.sourceLayer)
+        .length !== 1
+    )
+      continue
+    const connection = bus.connections.find(
+      (c) => c.connectionIndex === plan.connectionIndex,
+    )!
+    for (const alignGridToPads of [true, false]) {
+      const candidate = routeViaMinimalWinding({
+        ...params,
+        bus: {
+          ...bus,
+          connections: [connection],
+          routableEscapeLayers: [plan.targetLayer],
+        },
+        terminals: [
+          { connection, viaPoint: plan.via.center, exitPoint: plan.exitPoint },
+        ],
+        targetLayer: plan.targetLayer,
+        acceptedPlans: plans.filter((p) => p !== plan),
+        allowBlindAndBuriedVias: false,
+        gridStepDivisor: 2,
+        alignGridToPads,
+        maximumRouteOrderAttempts: 1,
+      })?.[0]
+      if (!candidate || candidate.length >= plan.length - 1e-6) continue
+      const nextPlans = plans.map((p) => (p === plan ? candidate : p))
+      if (
+        !fanoutPlansAreClear({
+          ...params,
+          plans: nextPlans,
+          allowBlindAndBuriedVias: false,
+        })
+      )
+        continue
+      plans = nextPlans
+      break
+    }
+  }
+  return plans
+}

package/lib/types.ts

@@ -388,6 +388,8 @@ export interface FanoutRoutePlan {
   exitPoint: Point2D
   trace: FanoutSimplifiedPcbTrace
   segments: RoutedSegment[]
+  /** Validated winding segments that leave this route's own source pad. */
+  sourceEscapeSegmentCount?: number
   via?: RoutedVia
   /** Additional layer transitions used by an explicit winding channel. */
   additionalVias?: RoutedVia[]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fanout-solver",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "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": "bun benchmarks/run-srj29-benchmark.ts",
+    "generate:dataset31": "bun scripts/generate-repro/generate-dataset31.tsx",
     "render:dataset": "bun scripts/render-dataset-pngs.ts",
     "format": "biome format --write .",
     "format:check": "biome format ."