Function memoizeAsyncWithLRU

src/utils/memoize.ts:280–347

(
  f: (...args: Args) => Promise<Result>,
  cacheFn: (...args: Args) => string,
  maxCacheSize: number = 100,
  cacheLifetimeMs: number = 5 * 60 * 1000,
)

 * - Rejected promises are NOT cached (next caller retries)
 */
export function memoizeAsyncWithLRU<
  Args extends unknown[],
  Result,
>(
  f: (...args: Args) => Promise<Result>,
  cacheFn: (...args: Args) => string,
  maxCacheSize: number = 100,
  cacheLifetimeMs: number = 5 * 60 * 1000,
): {
  (...args: Args): Promise<Result>
  cache: {
    clear: () => void
    delete: (key: string) => boolean
    size: () => number
    has: (key: string) => boolean
  }
} {
  type Entry = { value: Result; timestamp: number }
  const cache = new LRUCache<string, Entry>({ max: maxCacheSize })
  const inFlight = new Map<string, Promise<Result>>()

  const memoized = async (...args: Args): Promise<Result> => {
    const key = cacheFn(...args)
    const cached = cache.get(key)
    const now = Date.now()

    if (cached && now - cached.timestamp <= cacheLifetimeMs) {
      return cached.value
    }

    if (cached) {
      cache.delete(key)
    }

    const pending = inFlight.get(key)
    if (pending) return pending

    const promise = f(...args)
    inFlight.set(key, promise)

    try {
      const result = await promise
      if (inFlight.get(key) === promise) {
        cache.set(key, { value: result, timestamp: now })
      }
      return result
    } catch (e) {
      // Don't cache failures
      throw e
    } finally {
      if (inFlight.get(key) === promise) {
        inFlight.delete(key)
      }
    }
  }

  memoized.cache = {
    clear: () => {