@tscircuit/fanout-solver 0.0.53 → 0.0.54

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.53",
+  "version": "0.0.54",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",