@evoscientist/webui 0.2.4 → 0.2.6

package/dist/node_modules/next/dist/server/use-cache/cache-life-profile.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateAndNormalizeCacheLifeProfile", {
+    enumerable: true,
+    get: function() {
+        return validateAndNormalizeCacheLifeProfile;
+    }
+});
+const _constants = require("../../lib/constants");
+function normalizeCacheLifeValue(key, value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === false) {
+        if (key === 'stale') {
+            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you want to cache on the client forever ' + 'without checking with the server.'), "__NEXT_ERROR_CODE", {
+                value: "E407",
+                enumerable: false,
+                configurable: true
+            });
+        } else if (key === 'revalidate') {
+            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you do not want to revalidate by time.'), "__NEXT_ERROR_CODE", {
+                value: "E104",
+                enumerable: false,
+                configurable: true
+            });
+        } else {
+            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you want to cache on the server forever ' + 'without checking with the origin.'), "__NEXT_ERROR_CODE", {
+                value: "E658",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    if (typeof value !== 'number') {
+        throw Object.defineProperty(new Error(`The ${key} option must be a number of seconds.`), "__NEXT_ERROR_CODE", {
+            value: "E1414",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (value === Infinity) {
+        // Infinity means "never", but turns into null when serialized as JSON
+        // (e.g. for build workers or cache handlers), unlike INFINITE_CACHE.
+        return _constants.INFINITE_CACHE;
+    }
+    if (!Number.isFinite(value)) {
+        throw Object.defineProperty(new Error(context.kind === 'config' ? `Invalid "cacheLife.${context.profileName}.${key}" provided, expected a finite number of seconds or Infinity, received ${value}` : `Invalid \`cacheLife()\` option "${key}" provided, expected a finite number of seconds or Infinity, received ${value}.`), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return value;
+}
+function validateAndNormalizeCacheLifeProfile(profile, context) {
+    // Don't mutate the profile; it may be shared, e.g. as part of the user's
+    // config object.
+    const normalizedProfile = {
+        ...profile
+    };
+    for (const key of [
+        'stale',
+        'revalidate',
+        'expire'
+    ]){
+        const value = normalizeCacheLifeValue(key, profile[key], context);
+        if (value !== undefined) {
+            normalizedProfile[key] = value;
+        }
+    }
+    if (normalizedProfile.revalidate !== undefined && normalizedProfile.expire !== undefined && normalizedProfile.revalidate > normalizedProfile.expire) {
+        throw Object.defineProperty(new Error('If providing both the revalidate and expire options, ' + 'the expire option must be greater than the revalidate option. ' + 'The expire option indicates how many seconds from the start ' + 'until it can no longer be used.'), "__NEXT_ERROR_CODE", {
+            value: "E656",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return normalizedProfile;
+}
+
+//# sourceMappingURL=cache-life-profile.js.map

package/dist/node_modules/next/dist/server/use-cache/cache-life.js

@@ -8,65 +8,9 @@ Object.defineProperty(exports, "cacheLife", {
         return cacheLife;
     }
 });
-const _invarianterror = require("../../shared/lib/invariant-error");
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
-function validateCacheLife(profile) {
-    if (profile.stale !== undefined) {
-        if (profile.stale === false) {
-            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you want to cache on the client forever ' + 'without checking with the server.'), "__NEXT_ERROR_CODE", {
-                value: "E407",
-                enumerable: false,
-                configurable: true
-            });
-        } else if (typeof profile.stale !== 'number') {
-            throw Object.defineProperty(new Error('The stale option must be a number of seconds.'), "__NEXT_ERROR_CODE", {
-                value: "E308",
-                enumerable: false,
-                configurable: true
-            });
-        }
-    }
-    if (profile.revalidate !== undefined) {
-        if (profile.revalidate === false) {
-            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you do not want to revalidate by time.'), "__NEXT_ERROR_CODE", {
-                value: "E104",
-                enumerable: false,
-                configurable: true
-            });
-        } else if (typeof profile.revalidate !== 'number') {
-            throw Object.defineProperty(new Error('The revalidate option must be a number of seconds.'), "__NEXT_ERROR_CODE", {
-                value: "E233",
-                enumerable: false,
-                configurable: true
-            });
-        }
-    }
-    if (profile.expire !== undefined) {
-        if (profile.expire === false) {
-            throw Object.defineProperty(new Error('Pass `Infinity` instead of `false` if you want to cache on the server forever ' + 'without checking with the origin.'), "__NEXT_ERROR_CODE", {
-                value: "E658",
-                enumerable: false,
-                configurable: true
-            });
-        } else if (typeof profile.expire !== 'number') {
-            throw Object.defineProperty(new Error('The expire option must be a number of seconds.'), "__NEXT_ERROR_CODE", {
-                value: "E3",
-                enumerable: false,
-                configurable: true
-            });
-        }
-    }
-    if (profile.revalidate !== undefined && profile.expire !== undefined) {
-        if (profile.revalidate > profile.expire) {
-            throw Object.defineProperty(new Error('If providing both the revalidate and expire options, ' + 'the expire option must be greater than the revalidate option. ' + 'The expire option indicates how many seconds from the start ' + 'until it can no longer be used.'), "__NEXT_ERROR_CODE", {
-                value: "E656",
-                enumerable: false,
-                configurable: true
-            });
-        }
-    }
-}
+const _cachelifeprofile = require("./cache-life-profile");
 function cacheLife(profile) {
     if (!process.env.__NEXT_USE_CACHE) {
         throw Object.defineProperty(new Error('`cacheLife()` is only available with the `cacheComponents` config.'), "__NEXT_ERROR_CODE", {
@@ -107,13 +51,6 @@ function cacheLife(profile) {
                 configurable: true
             });
         }
-        if (!workStore.cacheLifeProfiles) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('`cacheLifeProfiles` should always be provided.'), "__NEXT_ERROR_CODE", {
-                value: "E817",
-                enumerable: false,
-                configurable: true
-            });
-        }
         // TODO: This should be globally available and not require an AsyncLocalStorage.
         const configuredProfile = workStore.cacheLifeProfiles[profile];
         if (configuredProfile === undefined) {
@@ -138,7 +75,9 @@ function cacheLife(profile) {
             configurable: true
         });
     } else {
-        validateCacheLife(profile);
+        profile = (0, _cachelifeprofile.validateAndNormalizeCacheLifeProfile)(profile, {
+            kind: 'inline'
+        });
     }
     if (profile.revalidate !== undefined) {
         // Track the explicit revalidate time.

package/dist/node_modules/next/dist/server/use-cache/clone-cache-entry.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cloneCacheEntry", {
+    enumerable: true,
+    get: function() {
+        return cloneCacheEntry;
+    }
+});
+function cloneCacheEntry(entry) {
+    const [streamA, streamB] = entry.value.tee();
+    entry.value = streamA;
+    const clonedEntry = {
+        value: streamB,
+        timestamp: entry.timestamp,
+        revalidate: entry.revalidate,
+        expire: entry.expire,
+        stale: entry.stale,
+        tags: entry.tags
+    };
+    return [
+        entry,
+        clonedEntry
+    ];
+}
+
+//# sourceMappingURL=clone-cache-entry.js.map

package/dist/node_modules/next/dist/server/use-cache/constants.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    DYNAMIC_EXPIRE: null,
-    RUNTIME_PREFETCH_DYNAMIC_STALE: null
+    MIN_PREFETCHABLE_STALE: null,
+    MIN_PRERENDERABLE_EXPIRE: null,
+    MIN_SHELL_STALE: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -13,16 +14,31 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    DYNAMIC_EXPIRE: function() {
-        return DYNAMIC_EXPIRE;
+    MIN_PREFETCHABLE_STALE: function() {
+        return MIN_PREFETCHABLE_STALE;
     },
-    RUNTIME_PREFETCH_DYNAMIC_STALE: function() {
-        return RUNTIME_PREFETCH_DYNAMIC_STALE;
+    MIN_PRERENDERABLE_EXPIRE: function() {
+        return MIN_PRERENDERABLE_EXPIRE;
+    },
+    MIN_SHELL_STALE: function() {
+        return MIN_SHELL_STALE;
     }
 });
-const DYNAMIC_EXPIRE = 300 // 5 minutes
+const _invarianterror = require("../../shared/lib/invariant-error");
+const MIN_PRERENDERABLE_EXPIRE = 300 // 5 minutes
+;
+const MIN_PREFETCHABLE_STALE = 30 // 30 seconds
 ;
-const RUNTIME_PREFETCH_DYNAMIC_STALE = 30 // 30 seconds
+const MIN_SHELL_STALE = 300 // 5 minutes
 ;
+if (process.env.NODE_ENV !== 'production') {
+    if (MIN_PREFETCHABLE_STALE > MIN_SHELL_STALE) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('MIN_PREFETCHABLE_STALE must not exceed MIN_SHELL_STALE.'), "__NEXT_ERROR_CODE", {
+            value: "E1422",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
 
 //# sourceMappingURL=constants.js.map

package/dist/node_modules/next/dist/server/use-cache/handlers.js

@@ -6,7 +6,12 @@ Object.defineProperty(exports, "__esModule", {
     getCacheHandler: null,
     getCacheHandlerEntries: null,
     getCacheHandlers: null,
+    getDevTieredCacheHandler: null,
+    getPrivateCacheHandler: null,
     initializeCacheHandlers: null,
+    isBuiltInCacheHandler: null,
+    isCustomCacheHandler: null,
+    isMemoryCacheDisabled: null,
     setCacheHandler: null
 });
 function _export(target, all) {
@@ -25,20 +30,47 @@ _export(exports, {
     getCacheHandlers: function() {
         return getCacheHandlers;
     },
+    getDevTieredCacheHandler: function() {
+        return getDevTieredCacheHandler;
+    },
+    getPrivateCacheHandler: function() {
+        return getPrivateCacheHandler;
+    },
     initializeCacheHandlers: function() {
         return initializeCacheHandlers;
     },
+    isBuiltInCacheHandler: function() {
+        return isBuiltInCacheHandler;
+    },
+    isCustomCacheHandler: function() {
+        return isCustomCacheHandler;
+    },
+    isMemoryCacheDisabled: function() {
+        return isMemoryCacheDisabled;
+    },
     setCacheHandler: function() {
         return setCacheHandler;
     }
 });
 const _default = require("../lib/cache-handlers/default");
+const _tieredcachehandler = require("./tiered-cache-handler");
 const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? (message, ...args)=>{
     console.log(`use-cache: ${message}`, ...args);
 } : undefined;
 const handlersSymbol = Symbol.for('@next/cache-handlers');
 const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
 const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+const privateHandlerSymbol = Symbol.for('@next/cache-handlers-private');
+const builtInHandlersSymbol = Symbol.for('@next/cache-handlers-built-in');
+const devFrontHandlersSymbol = Symbol.for('@next/cache-handlers-dev-fronts');
+const devTieredHandlersSymbol = Symbol.for('@next/cache-handlers-dev-tiered');
+const memoryCacheDisabledSymbol = Symbol.for('@next/cache-handlers-memory-disabled');
+/**
+ * The in-memory size used for the dev-only built-in handlers (the private
+ * handler, the size-0 replacement, and the per-kind front handlers for custom
+ * kinds). Mirrors the framework default so `cacheMaxMemorySize: 0` does not
+ * disable caching in development.
+ */ const DEV_MEMORY_CACHE_SIZE = 50 * 1024 * 1024;
 /**
  * The reference to the cache handlers. We store the cache handlers on the
  * global object so that we can access the same instance across different
@@ -51,7 +83,16 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
         return false;
     }
     debug == null ? void 0 : debug('initializing cache handlers');
-    reference[handlersMapSymbol] = new Map();
+    const handlersMap = new Map();
+    reference[handlersMapSymbol] = handlersMap;
+    const builtInHandlers = new Set();
+    reference[builtInHandlersSymbol] = builtInHandlers;
+    // In development, `cacheMaxMemorySize: 0` would make the built-in default
+    // handler a no-op, so every reload would miss. Use a real in-memory size
+    // instead so dev stays fast; the "use cache" wrapper forces a dynamic cache
+    // life for this case so it still behaves close to "no cache" (serve stale,
+    // regenerate in the background). Production keeps the no-op handler.
+    const builtInSize = process.env.__NEXT_DEV_SERVER && cacheMaxMemorySize === 0 ? DEV_MEMORY_CACHE_SIZE : cacheMaxMemorySize;
     // Initialize the cache from the symbol contents first.
     if (reference[handlersSymbol]) {
         let fallback;
@@ -60,25 +101,46 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
             fallback = reference[handlersSymbol].DefaultCache;
         } else {
             debug == null ? void 0 : debug('setting "default" cache handler from default');
-            fallback = (0, _default.createDefaultCacheHandler)(cacheMaxMemorySize);
+            fallback = (0, _default.createDefaultCacheHandler)(builtInSize);
+            builtInHandlers.add(fallback);
         }
-        reference[handlersMapSymbol].set('default', fallback);
+        handlersMap.set('default', fallback);
         if (reference[handlersSymbol].RemoteCache) {
             debug == null ? void 0 : debug('setting "remote" cache handler from symbol');
-            reference[handlersMapSymbol].set('remote', reference[handlersSymbol].RemoteCache);
+            handlersMap.set('remote', reference[handlersSymbol].RemoteCache);
         } else {
             debug == null ? void 0 : debug('setting "remote" cache handler from default');
-            reference[handlersMapSymbol].set('remote', fallback);
+            handlersMap.set('remote', fallback);
         }
     } else {
-        const handler = (0, _default.createDefaultCacheHandler)(cacheMaxMemorySize);
+        const handler = (0, _default.createDefaultCacheHandler)(builtInSize);
+        builtInHandlers.add(handler);
         debug == null ? void 0 : debug('setting "default" cache handler from default');
-        reference[handlersMapSymbol].set('default', handler);
+        handlersMap.set('default', handler);
         debug == null ? void 0 : debug('setting "remote" cache handler from default');
-        reference[handlersMapSymbol].set('remote', handler);
+        handlersMap.set('remote', handler);
     }
     // Create a set of the cache handlers.
-    reference[handlersSetSymbol] = new Set(reference[handlersMapSymbol].values());
+    reference[handlersSetSymbol] = new Set(handlersMap.values());
+    // In development we add dedicated built-in in-memory handlers so that reloads
+    // are fast. These are always built-in handlers, never a user-configured one,
+    // and are gated on the dev server so production behaves exactly as
+    // configured.
+    if (process.env.__NEXT_DEV_SERVER) {
+        reference[memoryCacheDisabledSymbol] = cacheMaxMemorySize === 0;
+        // Private caches are persisted here so reloads are fast. Private entries
+        // can hold data specific to the incoming request (for example, derived from
+        // its cookies or headers), so this is never the user-configured `default`
+        // alias. Sized so it still caches under `cacheMaxMemorySize: 0` (otherwise
+        // it would become the no-op stub and private reloads would miss).
+        reference[privateHandlerSymbol] = (0, _default.createDefaultCacheHandler)(DEV_MEMORY_CACHE_SIZE);
+        // Built-in front handlers, one per custom kind, and the tiered handlers
+        // that place a front in front of a (possibly slow or remote) backing
+        // handler so cache hits resolve in a microtask, are both created per kind
+        // in `setCacheHandler`.
+        reference[devFrontHandlersSymbol] = new Map();
+        reference[devTieredHandlersSymbol] = new Map();
+    }
     return true;
 }
 function getCacheHandler(kind) {
@@ -92,17 +154,93 @@ function getCacheHandler(kind) {
     }
     return reference[handlersMapSymbol].get(kind);
 }
+function getPrivateCacheHandler() {
+    // This should never be called before initializeCacheHandlers.
+    if (!reference[handlersMapSymbol]) {
+        throw Object.defineProperty(new Error('Cache handlers not initialized'), "__NEXT_ERROR_CODE", {
+            value: "E649",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return reference[privateHandlerSymbol];
+}
+function isMemoryCacheDisabled() {
+    return reference[memoryCacheDisabledSymbol] ?? false;
+}
+function isCustomCacheHandler(kind) {
+    var _reference_devFrontHandlersSymbol;
+    if (!process.env.__NEXT_DEV_SERVER) {
+        return false;
+    }
+    return ((_reference_devFrontHandlersSymbol = reference[devFrontHandlersSymbol]) == null ? void 0 : _reference_devFrontHandlersSymbol.has(kind)) ?? false;
+}
+function isBuiltInCacheHandler(kind) {
+    var _reference_handlersMapSymbol, _reference_builtInHandlersSymbol;
+    const handler = (_reference_handlersMapSymbol = reference[handlersMapSymbol]) == null ? void 0 : _reference_handlersMapSymbol.get(kind);
+    return handler !== undefined && Boolean((_reference_builtInHandlersSymbol = reference[builtInHandlersSymbol]) == null ? void 0 : _reference_builtInHandlersSymbol.has(handler));
+}
+function getDevTieredCacheHandler(kind) {
+    var _reference_devTieredHandlersSymbol;
+    if (!process.env.__NEXT_DEV_SERVER) {
+        return undefined;
+    }
+    return (_reference_devTieredHandlersSymbol = reference[devTieredHandlersSymbol]) == null ? void 0 : _reference_devTieredHandlersSymbol.get(kind);
+}
 function getCacheHandlers() {
-    if (!reference[handlersSetSymbol]) {
+    const handlersSet = reference[handlersSetSymbol];
+    if (!handlersSet) {
         return undefined;
     }
-    return reference[handlersSetSymbol].values();
+    if (process.env.__NEXT_DEV_SERVER) {
+        return iterateCacheHandlersWithDevBuiltIns(handlersSet);
+    }
+    return handlersSet.values();
+}
+/**
+ * Yields the registered handlers plus the dev-only built-in handlers (the
+ * private handler and the per-kind front handlers). The built-in handlers are
+ * not part of the registered set, but tag operations must still reach them:
+ * their `updateTags` writes the shared tags manifest that their `get` consults,
+ * so `revalidateTag` can invalidate their entries.
+ */ function* iterateCacheHandlersWithDevBuiltIns(handlersSet) {
+    yield* handlersSet;
+    const privateHandler = reference[privateHandlerSymbol];
+    if (privateHandler) {
+        yield privateHandler;
+    }
+    const devFrontHandlers = reference[devFrontHandlersSymbol];
+    if (devFrontHandlers) {
+        yield* devFrontHandlers.values();
+    }
 }
 function getCacheHandlerEntries() {
-    if (!reference[handlersMapSymbol]) {
+    const handlersMap = reference[handlersMapSymbol];
+    if (!handlersMap) {
         return undefined;
     }
-    return reference[handlersMapSymbol].entries();
+    if (process.env.__NEXT_DEV_SERVER) {
+        return iterateCacheHandlerEntriesWithDevBuiltIns(handlersMap);
+    }
+    return handlersMap.entries();
+}
+/**
+ * Yields the registered entries plus the dev-only private handler under its
+ * kind, so that per-kind tag operations (`refreshTags` / `getExpiration` for
+ * implicit tags) apply to private entries. Custom-kind front handlers are
+ * intentionally omitted: the backing handler (already in the map) is
+ * authoritative for that kind's `getExpiration`, and a front entry is discarded
+ * via that same value.
+ */ function* iterateCacheHandlerEntriesWithDevBuiltIns(handlersMap) {
+    yield* handlersMap.entries();
+    const privateHandler = reference[privateHandlerSymbol];
+    if (privateHandler) {
+        const privateEntry = [
+            'private',
+            privateHandler
+        ];
+        yield privateEntry;
+    }
 }
 function setCacheHandler(kind, cacheHandler) {
     // This should never be called before initializeCacheHandlers.
@@ -116,6 +254,21 @@ function setCacheHandler(kind, cacheHandler) {
     debug == null ? void 0 : debug('setting cache handler for "%s"', kind);
     reference[handlersMapSymbol].set(kind, cacheHandler);
     reference[handlersSetSymbol].add(cacheHandler);
+    // A user-configured handler may be slow or remote. In development, give it a
+    // dedicated built-in in-memory front handler so cache hits resolve in a
+    // microtask, and pair the two into a tiered handler the wrapper reads
+    // through. Both are created alongside registration so their lifecycle matches
+    // the backing handler's, and the front handler's presence is the signal that
+    // this kind is backed by a real handler (see `isCustomCacheHandler`). Being a
+    // built-in default handler, the front inherits the dev minimum retention, so
+    // a short-`expire` value still hits the front instead of falling through to
+    // the slow backing on every read.
+    if (process.env.__NEXT_DEV_SERVER) {
+        var _reference_devFrontHandlersSymbol, _reference_devTieredHandlersSymbol;
+        const frontHandler = (0, _default.createDefaultCacheHandler)(DEV_MEMORY_CACHE_SIZE);
+        (_reference_devFrontHandlersSymbol = reference[devFrontHandlersSymbol]) == null ? void 0 : _reference_devFrontHandlersSymbol.set(kind, frontHandler);
+        (_reference_devTieredHandlersSymbol = reference[devTieredHandlersSymbol]) == null ? void 0 : _reference_devTieredHandlersSymbol.set(kind, (0, _tieredcachehandler.createTieredCacheHandler)(frontHandler, cacheHandler));
+    }
 }
 
 //# sourceMappingURL=handlers.js.map

package/dist/node_modules/next/dist/server/use-cache/tiered-cache-handler.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTieredCacheHandler", {
+    enumerable: true,
+    get: function() {
+        return createTieredCacheHandler;
+    }
+});
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _clonecacheentry = require("./clone-cache-entry");
+function createTieredCacheHandler(front, backing) {
+    // Holds the in-flight (or chained) background sync per key, so a sync for a
+    // key runs after any earlier one for that key rather than in parallel.
+    const inFlightSyncs = new Map();
+    function scheduleBackgroundSync(cacheKey, sync) {
+        // Serialize syncs per key: chain this one after any in-flight sync rather
+        // than running a second in parallel. The trailing sync still re-reads the
+        // backing, so the front converges to the latest state; a later read is
+        // never dropped in favor of an earlier, possibly stale, in-flight read.
+        const previous = inFlightSyncs.get(cacheKey);
+        let pending;
+        if (previous) {
+            pending = previous.then(sync);
+        } else {
+            pending = sync();
+        }
+        pending = pending.finally(()=>{
+            if (inFlightSyncs.get(cacheKey) === pending) {
+                inFlightSyncs.delete(cacheKey);
+            }
+        });
+        inFlightSyncs.set(cacheKey, pending);
+        // Register the sync on the current request's revalidation writes so it is
+        // awaited rather than left untracked. Reading the work store here (rather
+        // than capturing it at construction) is what lets the handler be a shared
+        // singleton; `get` always runs within the request's async context, so the
+        // store is present.
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        if (workStore) {
+            workStore.pendingRevalidateWrites ??= [];
+            workStore.pendingRevalidateWrites.push(pending);
+        }
+    }
+    return {
+        async get (cacheKey, softTags) {
+            const frontEntry = await front.get(cacheKey, softTags);
+            if (frontEntry) {
+                // Cache hit: serve immediately (in a microtask). A background reconcile
+                // keeps the front in sync with the backing for the next read;
+                // reconciles for the same key are serialized, so concurrent cache hits
+                // don't hit the backing in parallel.
+                scheduleBackgroundSync(cacheKey, ()=>reconcileFrontFromBacking(front, backing, cacheKey, softTags, frontEntry));
+                return frontEntry;
+            }
+            // Cold or evicted front entry: we pay the backing latency here (this is a
+            // read that may legitimately surface a cold cache indicator). A miss
+            // returns undefined and the "use cache" wrapper generates the entry and
+            // writes it through both tiers via `set`.
+            const backingEntry = await backing.get(cacheKey, softTags);
+            if (!backingEntry) {
+                return undefined;
+            }
+            // Mirror this freshly read backing entry into the front so the next read
+            // hits it. The mirror is serialized per key: if a sync is already
+            // running, this chains after it, so the front converges to this read even
+            // if the backing changed since that sync started.
+            const [servedEntry, mirroredEntry] = (0, _clonecacheentry.cloneCacheEntry)(backingEntry);
+            scheduleBackgroundSync(cacheKey, ()=>mirrorIntoFront(front, cacheKey, mirroredEntry));
+            return servedEntry;
+        },
+        async set (cacheKey, pendingEntry) {
+            // Write through to both tiers. The entry's value stream is single-use, so
+            // tee it into one entry per tier.
+            const entry = await pendingEntry;
+            const [frontEntry, backingEntry] = (0, _clonecacheentry.cloneCacheEntry)(entry);
+            await Promise.all([
+                front.set(cacheKey, Promise.resolve(frontEntry)),
+                backing.set(cacheKey, Promise.resolve(backingEntry))
+            ]);
+        }
+    };
+}
+/**
+ * After serving a cache hit from the front, consult the backing and mirror a
+ * newer entry into the front for the next read. Runs in the background;
+ * failures are non-fatal.
+ */ async function reconcileFrontFromBacking(front, backing, cacheKey, softTags, frontEntry) {
+    try {
+        const backingEntry = await backing.get(cacheKey, softTags);
+        if (!backingEntry) {
+            // The backing no longer has this entry (it was purged out-of-band). The
+            // cache-handler interface has no per-key delete, so evict the front entry
+            // by overwriting it with an already-expired copy: the next read sees a
+            // front miss, falls through to the (also empty) backing, and the wrapper
+            // regenerates. The entry we just served was the last stale read.
+            await front.set(cacheKey, Promise.resolve(toExpiredEntry(frontEntry)));
+            return;
+        }
+        if (backingEntry.timestamp > frontEntry.timestamp) {
+            await front.set(cacheKey, Promise.resolve(backingEntry));
+        } else {
+            // The front is already up to date, so the backing entry goes unused.
+            // Release its stream without awaiting: a teed stream's `cancel()` only
+            // settles once the sibling branch (retained by the backing handler) is
+            // also cancelled, so awaiting it here would hang the reconcile.
+            void backingEntry.value.cancel();
+        }
+    } catch  {
+    // Background warming; failures are non-fatal.
+    }
+}
+/**
+ * Mirror a backing entry into the front.
+ */ async function mirrorIntoFront(front, cacheKey, entry) {
+    try {
+        await front.set(cacheKey, Promise.resolve(entry));
+    } catch  {
+    // Background warming; failures are non-fatal.
+    }
+}
+/**
+ * Build an already-expired copy of an entry, used to evict it from the front
+ * handler (which has no per-key delete) once the backing no longer has it. The
+ * default handler treats a negative `expire` as an eviction sentinel and
+ * reports the entry as missing on the next read. A negative `expire` is used
+ * rather than `0` because the dev front handler enforces a minimum retention,
+ * so a `0` `expire` would be kept alive by that minimum instead of evicted. The
+ * value is never read once the entry is evicted, but it must carry at least one
+ * byte because the built-in LRU cache refuses to store size-0 entries.
+ */ function toExpiredEntry(entry) {
+    return {
+        ...entry,
+        expire: -1,
+        value: new ReadableStream({
+            start (controller) {
+                controller.enqueue(new Uint8Array(1));
+                controller.close();
+            }
+        })
+    };
+}
+
+//# sourceMappingURL=tiered-cache-handler.js.map