@tscircuit/fanout-solver 0.0.62 → 0.0.64

package/lib/fanout-solver.ts

@@ -1551,6 +1551,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 +1606,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 +1861,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 +1925,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 +2027,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 +2675,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 +3058,7 @@ export class FanoutSolver extends BaseSolver {
           }
         }
         if (!busPlans) {
+          if (bus.connections.length >= 8) failedWideBoundaryBus ??= bus
           debugDense("route:failed", bus.busId)
           return false
         }
@@ -3365,6 +3389,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 +3456,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 +3611,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 +3626,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 +3806,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 +3827,7 @@ export class FanoutSolver extends BaseSolver {
                     })),
                   }),
                 )
-                if (useAdaptiveJointPlaneSelection) {
+                if (useJointPlaneSelection) {
                   const acceptedPlans = [
                     ...candidatePlans,
                     ...feasibleAlternatePlanePlans,
@@ -4106,7 +4138,7 @@ export class FanoutSolver extends BaseSolver {
               )
               if (!alternatePlanePlans) return null
               feasibleAlternatePlanePlans = alternatePlanePlans
-              if (useAdaptiveJointPlaneSelection) {
+              if (useJointPlaneSelection) {
                 matchedPlaneBusesInRoutingOrder = []
                 return new Map([
                   ...fixedBoundaryViaPoints,
@@ -4620,6 +4652,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 ||

package/lib/geometry.ts

@@ -190,6 +190,25 @@ export function segmentsAreClear(
 ): boolean {
   if (first.layer !== second.layer) return true
   const requiredDistance = (first.width + second.width) / 2 + clearance
+  // Axis separation is a lower bound on the distance between the segments.
+  // Leave a conservative tolerance band to the exact check below.
+  const broadPhaseDistance = requiredDistance + EPSILON
+  if (
+    Math.min(first.start.x, first.end.x) -
+      Math.max(second.start.x, second.end.x) >
+      broadPhaseDistance ||
+    Math.min(second.start.x, second.end.x) -
+      Math.max(first.start.x, first.end.x) >
+      broadPhaseDistance ||
+    Math.min(first.start.y, first.end.y) -
+      Math.max(second.start.y, second.end.y) >
+      broadPhaseDistance ||
+    Math.min(second.start.y, second.end.y) -
+      Math.max(first.start.y, first.end.y) >
+      broadPhaseDistance
+  ) {
+    return true
+  }
   return (
     distanceSegmentToSegment(
       first.start,

package/lib/route-bus.ts

@@ -75,6 +75,8 @@ export interface RouteBusParams {
   alignWindingGridToPads?: boolean
   /** Bounds the final fixed-via winding fallback after ordered attempts. */
   fixedViaFallbackRouteOrderAttempts?: number
+  /** Retry caller-fixed sites while preserving future exit gaps during recovery. */
+  allowFixedViaReservedExitFallback?: boolean
   /** Skip this many otherwise-clear plane escapes when enumerating alternatives. */
   planeCandidateSkipCount?: number
   /** Dense corner-band phase that preserves existing lane centers when leading lanes are prepended. */
@@ -1951,6 +1953,8 @@ function planIsClearOfPlans(params: {
     clearance,
     blockingBusCounts,
   } = params
+  const planSegments = getPlanSegments(plan)
+  const planVias = getPlanVias(plan)
   for (const otherPlan of otherPlans) {
     if (
       allowSameNetMerges &&
@@ -1975,9 +1979,7 @@ function planIsClearOfPlans(params: {
         (blockingBusCounts.get(otherPlan.busId) ?? 0) + 1,
       )
     }
-    const planSegments = getPlanSegments(plan)
     const otherSegments = getPlanSegments(otherPlan)
-    const planVias = getPlanVias(plan)
     const otherVias = getPlanVias(otherPlan)
     for (const segment of planSegments) {
       for (const otherSegment of otherSegments) {
@@ -2606,6 +2608,7 @@ export function* routeBusAlternativesSteps(
     adaptiveWindingRouteOrder = false,
     alignWindingGridToPads = false,
     fixedViaFallbackRouteOrderAttempts = 24,
+    allowFixedViaReservedExitFallback = false,
     cornerBandTargetTrackOffset,
   } = params
   if (!Number.isInteger(maxAlternatives) || maxAlternatives < 1) {
@@ -2994,6 +2997,29 @@ export function* routeBusAlternativesSteps(
                     })),
                 ).flat()
               : []),
+            // A single-layer target permutation can also let an early lane
+            // close a future terminal's exit gap. Keep the original attempts
+            // first, then retry the same fixed sites with every exit reserved.
+            ...(allowFixedViaReservedExitFallback &&
+            fixedViaPointsByConnectionIndex &&
+            !getCornerSide(bus) &&
+            windingTargetOrderCount === 1 &&
+            bus.connections.length > 2
+              ? [true, false].map((preferTargetDirectedLaneBias) => ({
+                  label: `fixed-vias-reserved-exits-${preferTargetDirectedLaneBias}`,
+                  useViaInPad: false,
+                  getViaHandedness: () => 0 as const,
+                  getViaPoint: (connection: PreparedConnection) =>
+                    coordinatedViaPoints.get(connection.connectionIndex)!,
+                  maximumRouteOrderAttempts: Math.min(
+                    maximumThroughAllRouteOrderAttempts,
+                    fixedViaFallbackRouteOrderAttempts,
+                  ),
+                  windingOrderIndex: 0,
+                  preferTargetDirectedLaneBias,
+                  reserveTerminalExitPoints: true,
+                }))
+              : []),
           ]
         : []
     const planeTerminationsAlreadyOccupyTheFanout = acceptedPlans.some(

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

@@ -824,6 +824,13 @@ export function* routeViaMinimalWindingAlternativesSteps(
   const sharesNet = (first: string, second: string): boolean =>
     first === second ||
     (allowSameNetMerges && connectionsShareElectricalNet(srj, first, second))
+  const boundedBlockingSegments = blockingSegments.map((blocker) => ({
+    ...blocker,
+    minX: Math.min(blocker.segment.start.x, blocker.segment.end.x),
+    maxX: Math.max(blocker.segment.start.x, blocker.segment.end.x),
+    minY: Math.min(blocker.segment.start.y, blocker.segment.end.y),
+    maxY: Math.max(blocker.segment.start.y, blocker.segment.end.y),
+  }))
   const allBlockingVias = [...blockingVias, ...terminalVias]
   const maximumViaToTraceDistance = allBlockingVias.reduce(
     (maximum, { via }) =>
@@ -850,6 +857,10 @@ export function* routeViaMinimalWindingAlternativesSteps(
   }): boolean => {
     const { segment, terminal, acceptedAttemptSegments } = params
     const connectionName = terminal.connection.connection.name
+    const segmentMinX = Math.min(segment.start.x, segment.end.x)
+    const segmentMaxX = Math.max(segment.start.x, segment.end.x)
+    const segmentMinY = Math.min(segment.start.y, segment.end.y)
+    const segmentMaxY = Math.max(segment.start.y, segment.end.y)
     const requiredObstacleClearance = segment.width / 2 + clearance
     for (const obstacle of targetLayerObstacleIndex.querySegment(
       segment,
@@ -869,8 +880,19 @@ export function* routeViaMinimalWindingAlternativesSteps(
         return false
       }
     }
-    for (const blocker of blockingSegments) {
+    for (const blocker of boundedBlockingSegments) {
       if (sharesNet(connectionName, blocker.connectionName)) continue
+      const margin = (segment.width + blocker.segment.width) / 2 + clearance
+      // Keep the full clearance margin in the broad phase; the exact check
+      // retains the existing tolerance for nearby copper.
+      if (
+        segmentMaxX + margin < blocker.minX ||
+        segmentMinX - margin > blocker.maxX ||
+        segmentMaxY + margin < blocker.minY ||
+        segmentMinY - margin > blocker.maxY
+      ) {
+        continue
+      }
       if (
         distanceSegmentToSegment(
           segment.start,
@@ -878,7 +900,7 @@ export function* routeViaMinimalWindingAlternativesSteps(
           blocker.segment.start,
           blocker.segment.end,
         ) <
-        (segment.width + blocker.segment.width) / 2 + clearance - EPSILON
+        margin - EPSILON
       ) {
         return false
       }
@@ -887,13 +909,13 @@ export function* routeViaMinimalWindingAlternativesSteps(
       if (sharesNet(connectionName, blocker.connectionName)) continue
       const margin = (segment.width + blocker.segment.width) / 2 + clearance
       if (
-        Math.max(segment.start.x, segment.end.x) + margin <
+        segmentMaxX + margin <
           Math.min(blocker.segment.start.x, blocker.segment.end.x) ||
-        Math.min(segment.start.x, segment.end.x) - margin >
+        segmentMinX - margin >
           Math.max(blocker.segment.start.x, blocker.segment.end.x) ||
-        Math.max(segment.start.y, segment.end.y) + margin <
+        segmentMaxY + margin <
           Math.min(blocker.segment.start.y, blocker.segment.end.y) ||
-        Math.min(segment.start.y, segment.end.y) - margin >
+        segmentMinY - margin >
           Math.max(blocker.segment.start.y, blocker.segment.end.y)
       )
         continue
@@ -917,10 +939,6 @@ export function* routeViaMinimalWindingAlternativesSteps(
       )
         return false
     }
-    const segmentMinX = Math.min(segment.start.x, segment.end.x)
-    const segmentMaxX = Math.max(segment.start.x, segment.end.x)
-    const segmentMinY = Math.min(segment.start.y, segment.end.y)
-    const segmentMaxY = Math.max(segment.start.y, segment.end.y)
     for (
       let viaIndex = getFirstViaAtOrAfterX(
         segmentMinX - maximumViaToTraceDistance,
@@ -1151,18 +1169,33 @@ export function* routeViaMinimalWindingAlternativesSteps(
     )
     const previous = new Int32Array(stateCount).fill(-1)
     const heap = new MinHeap()
-    const heuristic = (point: Point2D): number => {
+    // A node is revisited with different incoming directions. Its distance
+    // estimate and lane penalty stay fixed throughout this terminal search.
+    const remainingDistances = new Float64Array(nodeCount)
+    const lanePenalties = new Float64Array(nodeCount)
+    const targetTrack = getPerpendicularAxis(
+      terminal.exitPoint,
+      boundaryDirection,
+    )
+    for (let nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) {
+      const point = nodes[nodeIndex]!.point
       const deltaX = Math.abs(point.x - terminal.exitPoint.x)
       const deltaY = Math.abs(point.y - terminal.exitPoint.y)
-      return (
+      remainingDistances[nodeIndex] =
         Math.max(deltaX, deltaY) + (Math.SQRT2 - 1) * Math.min(deltaX, deltaY)
-      )
+      const nextTrack = getPerpendicularAxis(point, boundaryDirection)
+      lanePenalties[nodeIndex] =
+        laneBias === 0
+          ? 0
+          : laneBias > 0
+            ? Math.max(0, targetTrack - nextTrack) * 0.2
+            : Math.max(0, nextTrack - targetTrack) * 0.2
     }
     for (const start of starts) {
       const state = start.nodeIndex * 9 + 8
       if (start.length >= distances[state]!) continue
       distances[state] = start.length
-      const remaining = heuristic(nodes[start.nodeIndex]!.point)
+      const remaining = remainingDistances[start.nodeIndex]!
       heap.push({
         node: start.nodeIndex,
         direction: 8,
@@ -1179,6 +1212,16 @@ export function* routeViaMinimalWindingAlternativesSteps(
       [0, -1],
       [1, -1],
     ] as const
+    // Preserve the original ascending neighbor order, but do not reconsider
+    // the five disallowed turns every time a directed state is expanded.
+    const nextDirectionsByIncoming = Array.from({ length: 9 }, (_, incoming) =>
+      directions.flatMap((_, directionIndex) => {
+        const delta = Math.abs(incoming - directionIndex)
+        return incoming === 8 || Math.min(delta, 8 - delta) <= 1
+          ? [directionIndex]
+          : []
+      }),
+    )
     const startsByNode = new Map<number, ConnectorCandidate[]>()
     for (const start of starts) {
       const values = startsByNode.get(start.nodeIndex) ?? []
@@ -1198,7 +1241,7 @@ export function* routeViaMinimalWindingAlternativesSteps(
       const currentDistance = distances[state]!
       if (
         current.score >
-        currentDistance + heuristic(nodes[current.node]!.point) + EPSILON
+        currentDistance + remainingDistances[current.node]! + EPSILON
       )
         continue
       expandedStateCount++
@@ -1257,17 +1300,9 @@ export function* routeViaMinimalWindingAlternativesSteps(
         }
       }
       const node = nodes[current.node]!
-      for (
-        let directionIndex = 0;
-        directionIndex < directions.length;
-        directionIndex++
-      ) {
-        if (current.direction !== 8) {
-          const rawDirectionDelta = Math.abs(current.direction - directionIndex)
-          if (Math.min(rawDirectionDelta, 8 - rawDirectionDelta) > 1) {
-            continue
-          }
-        }
+      for (const directionIndex of nextDirectionsByIncoming[
+        current.direction
+      ]!) {
         const [deltaColumn, deltaRow] = directions[directionIndex]!
         const column = node.column + deltaColumn
         const row = node.row + deltaRow
@@ -1278,17 +1313,7 @@ export function* routeViaMinimalWindingAlternativesSteps(
         const nextPoint = nodes[nextNode]!.point
         const addsTurn =
           current.direction !== 8 && current.direction !== directionIndex
-        const nextTrack = getPerpendicularAxis(nextPoint, boundaryDirection)
-        const targetTrack = getPerpendicularAxis(
-          terminal.exitPoint,
-          boundaryDirection,
-        )
-        const lanePenalty =
-          laneBias === 0
-            ? 0
-            : laneBias > 0
-              ? Math.max(0, targetTrack - nextTrack) * 0.2
-              : Math.max(0, nextTrack - targetTrack) * 0.2
+        const lanePenalty = lanePenalties[nextNode]!
         const nextDistance =
           currentDistance +
           (deltaColumn !== 0 && deltaRow !== 0
@@ -1319,7 +1344,7 @@ export function* routeViaMinimalWindingAlternativesSteps(
         if (edgeClearance[edgeIndex] === 2) continue
         distances[nextState] = nextDistance
         previous[nextState] = state
-        const remaining = heuristic(nextPoint)
+        const remaining = remainingDistances[nextNode]!
         heap.push({
           node: nextNode,
           direction: directionIndex,
@@ -1488,6 +1513,14 @@ export function* routeViaMinimalWindingAlternativesSteps(
 
   const alternatives: FanoutRoutePlan[][] = []
   const seenAlternativeKeys = new Set<string>()
+  // Different complete route orders can share the same unsuccessful prefix.
+  // Static obstacles/vias, grid and search limits belong to this invocation;
+  // the terminal, lane bias and already accepted copper identify the rest.
+  // A reused failure still emits its normal completion progress below.
+  const failedSearches = new Map<
+    string,
+    { expandedStateCount: number; searchBatch: number }
+  >()
   let routeOrderAttemptCount = 0
   for (const routeOrder of adaptiveRouteOrders()) {
     for (const laneBias of laneBiases) {
@@ -1507,13 +1540,36 @@ export function* routeViaMinimalWindingAlternativesSteps(
         terminalIndex++
       ) {
         const terminal = routeOrder[terminalIndex]!
+        const failedSearchKey = JSON.stringify([
+          terminals.indexOf(terminal),
+          laneBias,
+          acceptedAttemptSegments.map(({ connectionName, segment }) => [
+            connectionName,
+            segment.start.x,
+            segment.start.y,
+            segment.end.x,
+            segment.end.y,
+            segment.width,
+            segment.layer,
+          ]),
+        ])
+        const cachedFailure = failedSearches.get(failedSearchKey)
         const connectionSteps = routeOneSteps({
           terminal,
           acceptedAttemptSegments,
           laneBias,
         })
-        let connectionResult = connectionSteps.next()
-        let searchBatch = 0
+        let connectionResult: ReturnType<typeof connectionSteps.next> =
+          cachedFailure === undefined
+            ? connectionSteps.next()
+            : {
+                done: true,
+                value: {
+                  points: null,
+                  expandedStateCount: cachedFailure.expandedStateCount,
+                },
+              }
+        let searchBatch = cachedFailure?.searchBatch ?? 0
         let expandedStateCount = 0
         while (!connectionResult.done) {
           expandedStateCount = connectionResult.value.expandedStateCount
@@ -1560,6 +1616,10 @@ export function* routeViaMinimalWindingAlternativesSteps(
             : {}),
         }
         if (!points) {
+          failedSearches.set(failedSearchKey, {
+            expandedStateCount: finalExpandedStateCount,
+            searchBatch,
+          })
           if (
             adaptiveRouteOrder &&
             maximumRouteOrderAttempts !== undefined &&

package/package.json

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