@tscircuit/fanout-solver 0.0.63 → 0.0.65

package/lib/fanout-solver.ts

@@ -39,6 +39,13 @@ import {
   routeBusAlternatives,
   routeBusAlternativesSteps,
 } from "./route-bus"
+import { routePeripheralSourceEscapesSteps } from "./route-peripheral-source-escapes"
+import { routeStagedPerimeterBusSteps } from "./route-staged-perimeter-bus"
+import { routeReservedSourceBusesSteps } from "./route-reserved-source-buses"
+import { repairPeripheralBusLengthsSteps } from "./repair-peripheral-bus-lengths"
+import { routeSplitPerimeterSourceEscapesSteps } from "./route-split-perimeter-source-escapes"
+import { routeSplitPerimeterBusSteps } from "./route-split-perimeter-bus"
+import { routeShallowSplitPerimeterBusSteps } from "./route-shallow-split-perimeter-bus"
 import { routeSingleLayerWithAdaptiveExitsSteps } from "./route-single-layer-adaptive-exits"
 import { routeSingleLayerWithPushAndShove } from "./route-single-layer-push-shove"
 import { getRuntimeProcess } from "./runtime-process"
@@ -84,6 +91,8 @@ interface ResolvedFanoutConfig {
 
 interface EvaluatedAssignment extends AssignmentAttempt {
   blockingBusIds: string[]
+  /** The bounded peripheral strategy may finish after complete validation. */
+  stopAfterCompleteValidation?: true
 }
 
 interface GroupedBeamState {
@@ -94,6 +103,7 @@ interface GroupedBeamState {
 interface MixedTerminationState {
   plans: FanoutRoutePlan[]
   failedBusIds: string[]
+  stopAfterCompleteValidation?: true
 }
 
 type RoutingStrategy = "default" | "group-by-layer" | "deep-first"
@@ -513,6 +523,43 @@ function createInitialLayerAssignment(params: {
     ) {
       assignment[bus.busId] = sourceLayer
     } else if (viaLayers.length > 0) {
+      // A source strictly inside a wide field can be enclosed by its routes.
+      // Boundary sources still have an outward channel, so preserve the
+      // ordinary layer preference for those buses.
+      const sourceXs = bus.connections.map(
+        (connection) => connection.sourcePoint.x,
+      )
+      const sourceYs = bus.connections.map(
+        (connection) => connection.sourcePoint.y,
+      )
+      const embeddedSingletonCount = (layer: string) =>
+        buses.filter((other) => {
+          const point = other.connections[0]?.sourcePoint
+          return (
+            other.termination.type === "boundary" &&
+            point !== undefined &&
+            point.x > Math.min(...sourceXs) + 1e-9 &&
+            point.x < Math.max(...sourceXs) - 1e-9 &&
+            point.y > Math.min(...sourceYs) + 1e-9 &&
+            point.y < Math.max(...sourceYs) - 1e-9 &&
+            getCommonExplicitExitTargetLayer(other) === layer &&
+            isDenseSingletonEmbeddedInMultiLayerWideBus({
+              singletonBus: other,
+              singletonTargetLayer: layer,
+              wideBuses: [bus],
+            })
+          )
+        }).length
+      const isolatedLayers = viaLayers.toSorted(
+        (a, b) => embeddedSingletonCount(a) - embeddedSingletonCount(b),
+      )
+      if (
+        embeddedSingletonCount(isolatedLayers[0]!) <
+        embeddedSingletonCount(viaLayers[0]!)
+      ) {
+        assignment[bus.busId] = isolatedLayers[0]!
+        continue
+      }
       if (
         preferOrderedCoordinatedWindingLayers &&
         busUsesCoordinatedWinding(bus)
@@ -1535,6 +1582,127 @@ export class FanoutSolver extends BaseSolver {
     })
   }
 
+  /** Reserve source escapes before joining complete buses around the package. */
+  private *routePeripheralMixedTerminationSteps(params: {
+    busLayerAssignments: Readonly<Record<string, string>>
+    busesInRoutingOrder: readonly PreparedBus[]
+  }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
+    if (this.config.allowBlindAndBuriedVias) return null
+    const bus = params.busesInRoutingOrder.find(
+      (candidate) =>
+        candidate.termination.type === "boundary" &&
+        (candidate.exitEdge === "right" || candidate.exitEdge === "left") &&
+        candidate.connections.length >= 16 &&
+        candidate.componentObstacles.length >= 200,
+    )
+    if (!bus) return null
+    const targetLayer = params.busLayerAssignments[bus.busId]
+    if (!targetLayer) return null
+    const targetLayerByBusId = new Map(
+      Object.entries(params.busLayerAssignments),
+    )
+    this.setInProgressPlans({
+      phase: "route-peripheral-source-escapes",
+      plans: [],
+      busId: bus.busId,
+    })
+    const sourceSteps = (
+      bus.exitEdge === "left"
+        ? routeSplitPerimeterSourceEscapesSteps
+        : routePeripheralSourceEscapesSteps
+    )({
+      ...this.config,
+      srj: this.routingSrj,
+      buses: this.preparedBuses,
+      bus,
+      targetLayer,
+      targetLayerByBusId,
+    })
+    let sourceResult = sourceSteps.next()
+    while (!sourceResult.done) {
+      yield
+      sourceResult = sourceSteps.next()
+    }
+    if (!sourceResult.value) return null
+    let source = sourceResult.value
+    const stageParams = {
+      ...this.config,
+      ...source,
+      srj: this.routingSrj,
+      bus,
+      targetLayer,
+    }
+    const stageSteps =
+      "lowerConnectionIndices" in source
+        ? routeSplitPerimeterBusSteps({ ...stageParams, ...source })
+        : routeStagedPerimeterBusSteps(stageParams)
+    let stageResult = stageSteps.next()
+    while (!stageResult.done) {
+      yield
+      stageResult = stageSteps.next()
+    }
+    let stagePlans = stageResult.value
+    if (!stagePlans && "lowerConnectionIndices" in source) {
+      const shallowSteps = routeShallowSplitPerimeterBusSteps({
+        ...stageParams,
+        ...source,
+        buses: this.preparedBuses,
+      })
+      let shallowResult = shallowSteps.next()
+      while (!shallowResult.done) {
+        yield
+        shallowResult = shallowSteps.next()
+      }
+      if (shallowResult.value) {
+        source = shallowResult.value
+        stagePlans = shallowResult.value.plans
+      }
+    }
+    if (!stagePlans) return null
+    this.setInProgressPlans({
+      phase: "route-peripheral-bus-continuations",
+      plans: stagePlans,
+      busId: bus.busId,
+    })
+    const remainingSteps = routeReservedSourceBusesSteps({
+      ...this.config,
+      srj: this.routingSrj,
+      buses: this.preparedBuses,
+      sourceEscapes: source.sourceEscapes,
+      sourceBoundary: source.sourceBoundary,
+      initialPlans: stagePlans,
+      targetLayerByBusId,
+    })
+    let remainingResult = remainingSteps.next()
+    while (!remainingResult.done) {
+      yield
+      remainingResult = remainingSteps.next()
+    }
+    if (!remainingResult.value) return null
+    const repairSteps = repairPeripheralBusLengthsSteps({
+      ...this.config,
+      srj: this.routingSrj,
+      inputSrj: this.inputSrj,
+      plans: remainingResult.value,
+      preparedBuses: this.preparedBuses,
+      sharedBoundary: this.getValidationBoundary(),
+    })
+    let repairResult = repairSteps.next()
+    while (!repairResult.done) {
+      yield
+      repairResult = repairSteps.next()
+    }
+    if (!repairResult.value) return null
+    const plans = repairResult.value
+    const output = buildOutputSimpleRouteJson({
+      inputSrj: this.inputSrj,
+      plans,
+      layerNames: this.config.layerNames,
+    })
+    if (!this.validateCompletePlans(plans, output).valid) return null
+    return { plans, failedBusIds: [], stopAfterCompleteValidation: true }
+  }
+
   /**
    * Through-all source vias from a wide boundary bus can consume the only
    * legal dogbone channel for nearby plane pads. Conversely, routing hundreds
@@ -1551,6 +1719,11 @@ export class FanoutSolver extends BaseSolver {
     promotedPlaneReservationBusIds?: readonly string[]
     preferredBoundaryViaPoints?: ReadonlyMap<number, { x: number; y: number }>
     planeReservationRetryCount?: number
+    boundaryRecovery?: {
+      busId: string
+      preferOutward: boolean
+      perpendicularSide: -1 | 1
+    }
   }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
     if (this.config.allowBlindAndBuriedVias) return null
     // An outside-package singleton escape can depend on the completed signal
@@ -1601,12 +1774,16 @@ export class FanoutSolver extends BaseSolver {
       )
     const useConfiguredDensePlaneRouting =
       configuredDensePlaneRouting || useAdaptiveDensePlaneRouting
+    const useBoundaryRecovery = params.boundaryRecovery !== undefined
+    const useJointPlaneRepair =
+      useConfiguredDensePlaneRouting || useBoundaryRecovery
     // A completed boundary assignment remains worth repairing jointly after
     // plane reservations change; a greedy refill can discard that assignment.
-    const useAdaptiveJointPlaneSelection =
-      useAdaptiveDensePlaneRouting &&
-      ((params.planeReservationRetryCount ?? 0) === 0 ||
-        Boolean(params.preferredBoundaryViaPoints))
+    const useJointPlaneSelection =
+      useBoundaryRecovery ||
+      (useAdaptiveDensePlaneRouting &&
+        ((params.planeReservationRetryCount ?? 0) === 0 ||
+          Boolean(params.preferredBoundaryViaPoints)))
     const matchLengthsAfterPlanes =
       useConfiguredDensePlaneRouting &&
       params.lengthMatchingStage !== "before-planes"
@@ -1852,7 +2029,9 @@ export class FanoutSolver extends BaseSolver {
       process.env.FANOUT_DEBUG_BOUNDARY_ORDER?.split(",") ??
       (process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS
         ? [process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS]
-        : [])
+        : params.boundaryRecovery
+          ? [params.boundaryRecovery.busId]
+          : [])
     const boundaryBuses =
       debugBoundaryOrder.length > 0
         ? initiallySortedBoundaryBuses.toSorted((first, second) => {
@@ -1914,6 +2093,7 @@ export class FanoutSolver extends BaseSolver {
       ]
     }
     const unroutablePlaneBusIds = new Set<string>()
+    let failedWideBoundaryBus: PreparedBus | undefined
     debugDense(
       "start",
       boundaryBuses.map((bus) => `${bus.busId}:${bus.connections.length}`),
@@ -2015,6 +2195,16 @@ export class FanoutSolver extends BaseSolver {
       if (entersNeighboringSourceField)
         preferBoundaryOutwardByBusId.set(bus.busId, false)
     }
+    if (params.boundaryRecovery) {
+      preferredBoundaryPerpendicularSideByBusId.set(
+        params.boundaryRecovery.busId,
+        params.boundaryRecovery.perpendicularSide,
+      )
+      preferBoundaryOutwardByBusId.set(
+        params.boundaryRecovery.busId,
+        params.boundaryRecovery.preferOutward,
+      )
+    }
     const debugFlippedBoundaryBus = process.env.FANOUT_DEBUG_FLIP_BOUNDARY_BUS
     if (debugFlippedBoundaryBus) {
       preferredBoundaryPerpendicularSideByBusId.set(debugFlippedBoundaryBus, -1)
@@ -2653,6 +2843,7 @@ export class FanoutSolver extends BaseSolver {
           allowBoundarySideViaFallback: bus.connections.length === 1,
           preferCornerBoundaryVia: useConfiguredDensePlaneRouting,
           adaptiveWindingRouteOrder,
+          allowFixedViaReservedExitFallback: useBoundaryRecovery,
           // Retain pad-aligned channels even when plane sites are reserved
           // adaptively; the boundary grid can fence off a turning wide bus.
           alignWindingGridToPads:
@@ -3035,6 +3226,7 @@ export class FanoutSolver extends BaseSolver {
           }
         }
         if (!busPlans) {
+          if (bus.connections.length >= 8) failedWideBoundaryBus ??= bus
           debugDense("route:failed", bus.busId)
           return false
         }
@@ -3365,6 +3557,7 @@ export class FanoutSolver extends BaseSolver {
           promotedAlternatePlaneBusIds: ReadonlySet<string> = new Set(),
         ): Map<number, { x: number; y: number }> | null => {
           feasibleAlternatePlanePlans = []
+          matchedPlaneBusesInRoutingOrder = null
           const fixedBoundaryViaPoints = new Map(
             candidatePlans.flatMap((plan) =>
               plan.via
@@ -3431,11 +3624,16 @@ export class FanoutSolver extends BaseSolver {
           if (retainedViaPoints)
             return new Map([...fixedBoundaryViaPoints, ...retainedViaPoints])
           if (
-            useConfiguredDensePlaneRouting ||
+            useJointPlaneRepair ||
             process.env.FANOUT_DEBUG_INCREMENTAL_PLANE_MATCH === "1"
           ) {
             let incrementalViaPoints = new Map(fixedBoundaryViaPoints)
-            const matchedPlaneBuses = [...activeBoundaryReservationPlaneBuses]
+            // Reservations guided the boundary search, but their copper is
+            // still uncommitted. Recovery must choose local and longer plane
+            // escapes together instead of locking every provisional site.
+            const matchedPlaneBuses = useBoundaryRecovery
+              ? []
+              : [...activeBoundaryReservationPlaneBuses]
             for (const planeBus of matchedPlaneBuses) {
               for (const connection of planeBus.connections) {
                 const reservedPoint = fixedViaPointsByConnectionIndex.get(
@@ -3581,7 +3779,7 @@ export class FanoutSolver extends BaseSolver {
                 independentlyUnmatchablePlaneBuses.map((bus) => bus.busId),
               )
               if (
-                !useConfiguredDensePlaneRouting &&
+                !useJointPlaneRepair &&
                 process.env.FANOUT_DEBUG_ROUTE_UNMATCHED_PLANES !== "1"
               ) {
                 return null
@@ -3596,7 +3794,9 @@ export class FanoutSolver extends BaseSolver {
                     ? 10_000
                     : useConfiguredDensePlaneRouting
                       ? 3_000_000
-                      : 1_000),
+                      : useBoundaryRecovery
+                        ? 10_000
+                        : 1_000),
               )
               const maximumAlternatePlaneRoutes = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_ROUTE_COUNT ??
@@ -3774,7 +3974,7 @@ export class FanoutSolver extends BaseSolver {
               }
               let alternatePlanePlans: FanoutRoutePlan[] | null
               if (
-                useConfiguredDensePlaneRouting ||
+                useJointPlaneRepair ||
                 process.env.FANOUT_DEBUG_EXACT_COVER_ALTERNATES === "1"
               ) {
                 type IndependentPlaneRouteCandidate = {
@@ -3795,7 +3995,7 @@ export class FanoutSolver extends BaseSolver {
                     })),
                   }),
                 )
-                if (useAdaptiveJointPlaneSelection) {
+                if (useJointPlaneSelection) {
                   const acceptedPlans = [
                     ...candidatePlans,
                     ...feasibleAlternatePlanePlans,
@@ -4106,7 +4306,7 @@ export class FanoutSolver extends BaseSolver {
               )
               if (!alternatePlanePlans) return null
               feasibleAlternatePlanePlans = alternatePlanePlans
-              if (useAdaptiveJointPlaneSelection) {
+              if (useJointPlaneSelection) {
                 matchedPlaneBusesInRoutingOrder = []
                 return new Map([
                   ...fixedBoundaryViaPoints,
@@ -4620,6 +4820,33 @@ export class FanoutSolver extends BaseSolver {
           denseRoutingStrategy: "boundary-aligned",
         })
       if (boundaryAlignedState) return boundaryAlignedState
+      // A later wide bus can be fenced by provisional through-vias even
+      // though its requested exit order is routable. After both existing
+      // grids fail, give that bus first choice of the field and retry the
+      // four dogbone orientations. The marker bounds recursion and enables
+      // joint selection of the remaining uncommitted plane escapes.
+      if (!useBoundaryRecovery && failedWideBoundaryBus) {
+        const busId = failedWideBoundaryBus.busId
+        const outward = preferBoundaryOutwardByBusId.get(busId) ?? true
+        const side = preferredBoundaryPerpendicularSideByBusId.get(busId) ?? 1
+        for (const [preferOutward, perpendicularSide] of [
+          [!outward, -side],
+          [!outward, side],
+          [outward, -side],
+          [outward, side],
+        ] as const) {
+          const recoveredState =
+            yield* this.routeDenseThroughAllMixedTerminationSteps({
+              ...params,
+              boundaryRecovery: {
+                busId,
+                preferOutward,
+                perpendicularSide: perpendicularSide as -1 | 1,
+              },
+            })
+          if (recoveredState) return recoveredState
+        }
+      }
     }
     if (
       !usePadAlignedDenseRouting ||
@@ -5083,6 +5310,23 @@ export class FanoutSolver extends BaseSolver {
 
     let mixedTerminationState: MixedTerminationState | null = null
     if (!useSingleLayerPushAndShove && routingStrategy === "default") {
+      const peripheralSolver = this.createWorkSolver(
+        "PeripheralMixedTerminationSolver",
+        this.routePeripheralMixedTerminationSteps({
+          busLayerAssignments,
+          busesInRoutingOrder,
+        }),
+      )
+      mixedTerminationState = (yield {
+        type: "subsolver",
+        solver: peripheralSolver,
+      }) as MixedTerminationState | null
+    }
+    if (
+      !mixedTerminationState &&
+      !useSingleLayerPushAndShove &&
+      routingStrategy === "default"
+    ) {
       const denseSolver = this.createWorkSolver(
         "DenseMixedTerminationSolver",
         this.routeDenseThroughAllMixedTerminationSteps({
@@ -5282,6 +5526,10 @@ export class FanoutSolver extends BaseSolver {
     return {
       summary,
       plans,
+      ...(mixedTerminationState?.stopAfterCompleteValidation &&
+      validation?.valid
+        ? { stopAfterCompleteValidation: true as const }
+        : {}),
       blockingBusIds: [...blockingBusCounts.entries()]
         .toSorted(([, firstCount], [, secondCount]) => secondCount - firstCount)
         .map(([busId]) => busId),
@@ -5302,7 +5550,8 @@ export class FanoutSolver extends BaseSolver {
     if (
       bestAttempt.summary.routedConnectionCount ===
         this.inputSrj.connections.length &&
-      this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0
+      (bestAttempt.stopAfterCompleteValidation ||
+        this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0)
     ) {
       return bestAttempt
     }
@@ -5319,7 +5568,8 @@ export class FanoutSolver extends BaseSolver {
       if (
         bestAttempt.summary.routedConnectionCount ===
           this.inputSrj.connections.length &&
-        this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0
+        (bestAttempt.stopAfterCompleteValidation ||
+          this.getCoordinatedAdditionalViaCount(bestAttempt.plans) === 0)
       ) {
         return bestAttempt
       }
@@ -5873,10 +6123,11 @@ export class FanoutSolver extends BaseSolver {
       bestScore: this.bestAttempt.summary.score,
     }
     if (
-      this.groupedBeamEvaluated &&
-      attempt.summary.routedConnectionCount ===
-        this.inputSrj.connections.length &&
-      this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0
+      (attempt.stopAfterCompleteValidation && this.hasCompleteBestAttempt()) ||
+      (this.groupedBeamEvaluated &&
+        attempt.summary.routedConnectionCount ===
+          this.inputSrj.connections.length &&
+        this.getCoordinatedAdditionalViaCount(this.bestAttempt.plans) === 0)
     ) {
       this.completeBestAttemptEndpoints()
       this.solved = true

package/lib/get-free-boundary-tracks.ts

@@ -0,0 +1,102 @@
+import { getCornerBandSide } from "./boundary-exit"
+import type { RouteBusParams } from "./route-bus"
+
+/** Midpoints of unoccupied edge intervals, clipped to the bus's declared band. */
+export function getFreeBoundaryTracks(
+  params: Pick<
+    RouteBusParams,
+    | "bus"
+    | "targetLayer"
+    | "acceptedPlans"
+    | "reservedVias"
+    | "traceWidth"
+    | "clearance"
+  >,
+): number[] {
+  const { bus, targetLayer, traceWidth, clearance } = params
+  if (!bus.exitEdge) return []
+  const vertical = bus.exitEdge === "left" || bus.exitEdge === "right"
+  const along = vertical ? "y" : "x"
+  const across = vertical ? "x" : "y"
+  const boundary = bus.sharedBoundary
+  const edge =
+    bus.exitEdge === "left"
+      ? boundary.minX
+      : bus.exitEdge === "right"
+        ? boundary.maxX
+        : bus.exitEdge === "bottom"
+          ? boundary.minY
+          : boundary.maxY
+  const lower = vertical ? boundary.minY : boundary.minX
+  const upper = vertical ? boundary.maxY : boundary.maxX
+  const middle = (lower + upper) / 2
+  const side = getCornerBandSide(bus.exitEdge, bus.preferredExit)
+  const minimum = (side === "maximum" ? middle : lower) + traceWidth / 2
+  const maximum = (side === "minimum" ? middle : upper) - traceWidth / 2
+  const blocked: [number, number][] = []
+  for (const plan of params.acceptedPlans) {
+    for (const segment of [
+      ...plan.segments,
+      ...(plan.planeEndpointSegments ?? []),
+    ]) {
+      if (segment.layer !== targetLayer) continue
+      const radius = (segment.width + traceWidth) / 2 + clearance
+      const start = segment.start[across]
+      const delta = segment.end[across] - start
+      let from = 0
+      let to = 1
+      if (Math.abs(delta) < 1e-9) {
+        if (Math.abs(start - edge) > radius) continue
+      } else {
+        const first = (edge - radius - start) / delta
+        const last = (edge + radius - start) / delta
+        from = Math.max(0, Math.min(first, last))
+        to = Math.min(1, Math.max(first, last))
+        if (from > to) continue
+      }
+      const alongStart = segment.start[along]
+      const alongDelta = segment.end[along] - alongStart
+      const first = alongStart + from * alongDelta
+      const last = alongStart + to * alongDelta
+      blocked.push([
+        Math.min(first, last) - radius,
+        Math.max(first, last) + radius,
+      ])
+    }
+  }
+  const vias = [
+    ...params.acceptedPlans.flatMap((plan) => [
+      ...(plan.via ? [plan.via] : []),
+      ...(plan.additionalVias ?? []),
+      ...(plan.planeEndpointVia ? [plan.planeEndpointVia] : []),
+    ]),
+    ...(params.reservedVias ?? []).map((reserved) => reserved.via),
+  ]
+  for (const via of vias) {
+    if (!via.spanLayers.includes(targetLayer)) continue
+    const radius = via.diameter / 2 + traceWidth / 2 + clearance
+    const distance = Math.abs(via.center[across] - edge)
+    if (distance >= radius) continue
+    const extent = Math.sqrt(radius * radius - distance * distance)
+    blocked.push([via.center[along] - extent, via.center[along] + extent])
+  }
+  const gaps: [number, number][] = []
+  let cursor = minimum
+  for (const [from, to] of blocked.sort((a, b) => a[0] - b[0])) {
+    if (to <= cursor || from >= maximum) continue
+    if (from > cursor) gaps.push([cursor, Math.min(from, maximum)])
+    cursor = Math.max(cursor, to)
+    if (cursor >= maximum) break
+  }
+  if (cursor < maximum) gaps.push([cursor, maximum])
+  // Edge order gives deterministic, symmetric coverage without hard-coded tracks.
+  const tracks = gaps
+    .filter(([from, to]) => to - from > 1e-6)
+    .map(([from, to]) => (from + to) / 2)
+  return tracks.length <= 32
+    ? tracks
+    : Array.from(
+        { length: 32 },
+        (_, index) => tracks[Math.round((index * (tracks.length - 1)) / 31)]!,
+      )
+}