Function coalesceLocally

apps/sim/lib/concurrency/singleflight.ts:30–67

(
  key: string,
  fn: () => Promise<T>,
  settleTimeoutMs: number = DEFAULT_SETTLE_TIMEOUT_MS
)

 * caller will join it.
 */
export function coalesceLocally<T>(
  key: string,
  fn: () => Promise<T>,
  settleTimeoutMs: number = DEFAULT_SETTLE_TIMEOUT_MS
): Promise<T> {
  const existing = inflight.get(key) as Promise<T> | undefined
  if (existing) return existing

  let timer: ReturnType<typeof setTimeout> | undefined
  const evict = () => {
    if (inflight.get(key) === guarded) inflight.delete(key)
  }

  const guarded: Promise<T> = Promise.race([
    (async () => {
      try {
        // Defer fn() to a microtask so a synchronous throw surfaces as a
        // rejection after `guarded` and the timer are initialized. Calling it
        // inline would run the finally below during construction, touching
        // `guarded` in its temporal dead zone and masking fn's real error.
        return await Promise.resolve().then(fn)
      } finally {
        clearTimeout(timer)
        evict()
      }
    })(),
    new Promise<never>((_, reject) => {
      timer = setTimeout(() => {
        evict()
        reject(new CoalesceSettleTimeoutError(key, settleTimeoutMs))
      }, settleTimeoutMs)
      timer.unref?.()
    }),
  ])

  inflight.set(key, guarded)
  return guarded
}

export function __resetCoalesceLocallyForTests(): void {
  inflight.clear()