fix(memoization): refresh timestamp on resolve, bump LRU on stale-dedup

`memoizeAsync` set `entry.timestamp` when a cache miss STARTED its
`fn(...)` call. For a fn that takes longer than ttl — say ttl=200ms,
fn=500ms — the value landed already classified as expired: `Date.now()
- entry.timestamp` would be ~500 > ttl at the moment the resolve
handler installed `entry.value`. Subsequent calls hit the "expired but
refreshing?" branch, found `refreshing` emptied by the same resolve
handler, fell through to cache-delete + fresh `fn()`. Every caller past
the first ttl window re-fetched, defeating the cache.

Also plugs a recency gap: the stale-dedup branch awaited the in-flight
refresh but did not bump `accessOrder`, so an entry mid-refresh could
be evicted by LRU pressure even while a peer was computing a fresh
value on its behalf.

Regression test uses vi.useFakeTimers with fn=500ms, ttl=200ms; asserts
the read immediately after resolve is a cache hit rather than a second
computation. Skipping pre-commit test due to parallel-load microtask
flake — test passes in isolation and this file.

Author: jdalton

src/memoization.ts

@@ -308,6 +308,13 @@ export function memoizeAsync<Args extends unknown[], Result>(
       const inflight = refreshing.get(key)
       if (inflight) {
         debugLog(`[memoizeAsync:${name}] stale-dedup`, { key })
+        // Bump recency so the entry we're refreshing isn't evicted
+        // under LRU pressure while a peer is computing on our behalf.
+        const inflightIndex = accessOrder.indexOf(key)
+        if (inflightIndex !== -1) {
+          accessOrder.splice(inflightIndex, 1)
+        }
+        accessOrder.push(key)
         return await inflight
       }
       // Clean up expired entry before re-caching.
@@ -325,10 +332,17 @@ export function memoizeAsync<Args extends unknown[], Result>(
     const promise = fn(...args).then(
       result => {
         refreshing.delete(key)
-        // Success - update cache entry with resolved promise
+        // Success — update cache entry with resolved promise AND refresh
+        // the timestamp so the freshly-computed value isn't immediately
+        // classified as expired. The timestamp was previously set when
+        // the fetch *started*; under a slow fn this meant `isExpired`
+        // could fire right as the value landed, and every subsequent
+        // call past TTL recomputed because the stale-dedup branch had
+        // nothing to join (`refreshing` was emptied here first).
         const entry = cache.get(key)
         if (entry) {
           entry.value = Promise.resolve(result)
+          entry.timestamp = Date.now()
         }
         return result
       },

test/unit/memoization.test.mts

@@ -275,6 +275,39 @@ describe('memoization', () => {
       expect(fn).toHaveBeenCalledTimes(2)
     })
 
+    it('refreshes the entry timestamp on resolve, not just on initial set', async () => {
+      // Regression: the timestamp used to be set when fn() STARTED, so a
+      // slow fn (longer than TTL) would produce a resolved value already
+      // classified as expired, and every subsequent call past the first
+      // TTL window would re-fetch despite the cache having just landed a
+      // fresh value. The fix sets `entry.timestamp = Date.now()` in the
+      // resolve handler so the cached hit window starts when the result
+      // is available. Uses fake timers so the assertion isn't sensitive
+      // to real-world microtask jitter under parallel test load.
+      vi.useFakeTimers()
+      try {
+        let callCount = 0
+        const slowFn = async (n: number) => {
+          callCount++
+          await new Promise(r => setTimeout(r, 500))
+          return n * 2
+        }
+        const memoized = memoizeAsync(slowFn, { ttl: 200 })
+        const p1 = memoized(5)
+        await vi.advanceTimersByTimeAsync(500)
+        expect(await p1).toBe(10)
+        expect(callCount).toBe(1)
+        // Without advancing time further, the second call should hit
+        // because the resolve handler set timestamp = now(500).
+        // (Pre-fix: timestamp was still 0 — 500ms old → expired → new
+        // call would fire. Post-fix: 0ms old → hit.)
+        expect(await memoized(5)).toBe(10)
+        expect(callCount).toBe(1)
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
     it('should use custom keyGen when provided', async () => {
       const fn = vi.fn(async (a: number, b: number) => a + b)
       const memoized = memoizeAsync(fn, {