@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/server/web/adapter.js

@@ -35,6 +35,7 @@ const _requeststore = require("../async-storage/request-store");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _workstore = require("../async-storage/work-store");
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _invarianterror = require("../../shared/lib/invariant-error");
 const _tracer = require("../lib/trace/tracer");
 const _constants = require("../lib/trace/constants");
 const _webonclose = require("./web-on-close");
@@ -43,6 +44,22 @@ const _builtinrequestcontext = require("../after/builtin-request-context");
 const _implicittags = require("../lib/implicit-tags");
 const _isrscrequest = require("../lib/is-rsc-request");
 const _requestmeta = require("../request-meta");
+// The proxy (middleware) does not support `'use cache'`, so this work store
+// never reaches the code that reads `cacheLife` (and `'use cache'` is
+// disallowed on the edge runtime anyway). This sentinel satisfies the
+// non-optional type while throwing if `default` is ever read, matching the
+// "never read" sentinels used for the proxy's other unused renderOpts fields
+// (`staticPageGenerationTimeout: 0`, `useCacheTimeout: 0`). It surfaces loudly
+// rather than silently serving a misleading profile.
+const proxyCacheLifeProfiles = {
+    get default () {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Proxy does not support `use cache`, so reading its `default` cacheLife profile is unexpected.'), "__NEXT_ERROR_CODE", {
+            value: "E1406",
+            enumerable: false,
+            configurable: true
+        });
+    }
+};
 class NextRequestHint extends _request.NextRequest {
     constructor(params){
         super(params.input, params.init);
@@ -225,7 +242,7 @@ async function adapter(params) {
                 }
             }, async ()=>{
                 try {
-                    var _params_request_nextConfig_experimental, _params_request_nextConfig, _params_request_nextConfig_experimental1, _params_request_nextConfig1;
+                    var _params_request_nextConfig_experimental, _params_request_nextConfig;
                     const onUpdateCookies = (cookies)=>{
                         cookiesFromResponse = cookies;
                     };
@@ -234,15 +251,31 @@ async function adapter(params) {
                     ;
                     const fallbackRouteParams = null;
                     const implicitTags = await (0, _implicittags.getImplicitTags)(page, request.nextUrl.pathname, fallbackRouteParams);
-                    const requestStore = (0, _requeststore.createRequestStoreForAPI)(request, request.nextUrl, implicitTags, onUpdateCookies, previewProps);
+                    const requestStore = (0, _requeststore.createRequestStoreForAPI)(request, request.nextUrl, implicitTags, onUpdateCookies, previewProps, // Edge route handlers can't use `"use cache"`, so there's no HMR
+                    // refresh hash to thread through here.
+                    undefined);
                     const workStore = (0, _workstore.createWorkStore)({
                         page,
                         renderOpts: {
-                            cacheLifeProfiles: (_params_request_nextConfig = params.request.nextConfig) == null ? void 0 : (_params_request_nextConfig_experimental = _params_request_nextConfig.experimental) == null ? void 0 : _params_request_nextConfig_experimental.cacheLife,
+                            cacheLifeProfiles: proxyCacheLifeProfiles,
+                            // Proxy doesn't do static generation, so this value does not
+                            // apply here. 0 is a sentinel: if something ever reads it,
+                            // it'll surface loudly instead of silently using a misleading
+                            // default.
+                            staticPageGenerationTimeout: 0,
                             cacheComponents: false,
+                            // Proxy doesn't run instant validation; the level value is
+                            // irrelevant here.
+                            // TODO: remove validationLevel and other global config from renderOpts
+                            validationLevel: 'warning',
                             experimental: {
                                 isRoutePPREnabled: false,
-                                authInterrupts: !!((_params_request_nextConfig1 = params.request.nextConfig) == null ? void 0 : (_params_request_nextConfig_experimental1 = _params_request_nextConfig1.experimental) == null ? void 0 : _params_request_nextConfig_experimental1.authInterrupts)
+                                authInterrupts: !!((_params_request_nextConfig = params.request.nextConfig) == null ? void 0 : (_params_request_nextConfig_experimental = _params_request_nextConfig.experimental) == null ? void 0 : _params_request_nextConfig_experimental.authInterrupts),
+                                // Proxy doesn't fill Cache Components entries, so this value
+                                // is never read. 0 is a sentinel: if something ever reads it,
+                                // the cache fill will time out immediately and surface the
+                                // bug.
+                                useCacheTimeout: 0
                             },
                             supportsDynamicResponse: true,
                             waitUntil,

package/dist/node_modules/next/dist/server/web/edge-route-module-wrapper.js

@@ -84,10 +84,22 @@ class EdgeRouteModuleWrapper {
                 onClose: closeController.onClose.bind(closeController),
                 onAfterTaskError: undefined,
                 cacheComponents: !!process.env.__NEXT_CACHE_COMPONENTS,
+                // Edge runtime doesn't run instant validation; the level value is
+                // irrelevant here.
+                // TODO: Remove validationLevel and other global config from renderOpts
+                validationLevel: 'warning',
                 experimental: {
-                    authInterrupts: !!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS
+                    authInterrupts: !!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS,
+                    // Edge runtime doesn't support Cache Components, so this value is
+                    // never read. 0 is a sentinel: if something ever reads it, the cache
+                    // fill will time out immediately and surface the bug.
+                    useCacheTimeout: 0
                 },
-                cacheLifeProfiles: nextConfig.cacheLife
+                cacheLifeProfiles: nextConfig.cacheLife,
+                // Edge runtime doesn't do static generation, so this value does not
+                // apply here. 0 is a sentinel: if something ever reads it, it'll
+                // surface loudly instead of silently using a misleading default.
+                staticPageGenerationTimeout: 0
             },
             sharedContext: {
                 buildId: '',

package/dist/node_modules/next/dist/server/web/error.js

@@ -34,6 +34,11 @@ class PageSignatureError extends Error {
   
   Read more: https://nextjs.org/docs/messages/middleware-new-signature
   `);
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1177",
+            enumerable: false,
+            configurable: true
+        });
     }
 }
 class RemovedPageError extends Error {
@@ -41,6 +46,11 @@ class RemovedPageError extends Error {
         super(`The request.page has been deprecated in favour of \`URLPattern\`.
   Read more: https://nextjs.org/docs/messages/middleware-request-page
   `);
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1178",
+            enumerable: false,
+            configurable: true
+        });
     }
 }
 class RemovedUAError extends Error {
@@ -48,6 +58,11 @@ class RemovedUAError extends Error {
         super(`The request.ua has been removed in favour of \`userAgent\` function.
   Read more: https://nextjs.org/docs/messages/middleware-parse-user-agent
   `);
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1172",
+            enumerable: false,
+            configurable: true
+        });
     }
 }
 

package/dist/node_modules/next/dist/server/web/sandbox/context.js

@@ -388,11 +388,17 @@ Learn More: https://nextjs.org/docs/messages/edge-dynamic-code-evaluation`), "__
             context.performance = performance;
             context.AsyncLocalStorage = _async_hooks.AsyncLocalStorage;
             // @ts-ignore the timeouts have weird types in the edge runtime
-            context.setInterval = (...args)=>_resourcemanagers.intervalsManager.add(args);
+            context.setInterval = (...args)=>_resourcemanagers.intervalsManager.add([
+                    context,
+                    ...args
+                ]);
             // @ts-ignore the timeouts have weird types in the edge runtime
             context.clearInterval = (interval)=>_resourcemanagers.intervalsManager.remove(interval);
             // @ts-ignore the timeouts have weird types in the edge runtime
-            context.setTimeout = (...args)=>_resourcemanagers.timeoutsManager.add(args);
+            context.setTimeout = (...args)=>_resourcemanagers.timeoutsManager.add([
+                    context,
+                    ...args
+                ]);
             // @ts-ignore the timeouts have weird types in the edge runtime
             context.clearTimeout = (timeout)=>_resourcemanagers.timeoutsManager.remove(timeout);
             // Duplicated from packages/next/src/server/after/builtin-request-context.ts

package/dist/node_modules/next/dist/server/web/sandbox/resource-managers.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    IntervalsManager: null,
+    TimeoutsManager: null,
     intervalsManager: null,
     timeoutsManager: null
 });
@@ -13,6 +15,12 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    IntervalsManager: function() {
+        return IntervalsManager;
+    },
+    TimeoutsManager: function() {
+        return TimeoutsManager;
+    },
     intervalsManager: function() {
         return intervalsManager;
     },
@@ -23,19 +31,31 @@ _export(exports, {
 class ResourceManager {
     add(resourceArgs) {
         const resource = this.create(resourceArgs);
-        this.resources.push(resource);
+        this.resources.add(resource);
         return resource;
     }
     remove(resource) {
-        this.resources = this.resources.filter((r)=>r !== resource);
+        this.untrack(resource);
         this.destroy(resource);
     }
+    /**
+   * Stop tracking a resource without destroying it. Used when a resource has
+   * already been released by other means (e.g. a one-shot timeout that ran to
+   * completion) so it should no longer be retained by this manager.
+   */ untrack(resource) {
+        this.resources.delete(resource);
+    }
     removeAll() {
-        this.resources.forEach(this.destroy);
-        this.resources = [];
+        for (const resource of this.resources){
+            this.destroy(resource);
+        }
+        this.resources.clear();
+    }
+    /** Number of resources currently tracked. Exposed for observability/tests. */ get size() {
+        return this.resources.size;
     }
     constructor(){
-        this.resources = [];
+        this.resources = new Set();
     }
 }
 class IntervalsManager extends ResourceManager {
@@ -50,27 +70,42 @@ class IntervalsManager extends ResourceManager {
 class TimeoutsManager extends ResourceManager {
     create(args) {
         // TODO: use the edge runtime provided `setTimeout` instead
-        return webSetTimeoutPolyfill(...args);
+        const [globalObject, callback, ms, ...rest] = args;
+        // A one-shot timeout releases itself from tracking once its callback has
+        // run. Otherwise fire-and-forget timeouts (whose ids user code never
+        // passes to `clearTimeout`) would accumulate for the lifetime of the
+        // module context and leak memory in long-lived server processes.
+        // See: https://github.com/vercel/next.js/issues/95094
+        let timeoutId;
+        const callbackWithRelease = (...callbackArgs)=>{
+            try {
+                return callback.apply(globalObject, callbackArgs);
+            } finally{
+                this.untrack(timeoutId);
+            }
+        };
+        timeoutId = webSetTimeoutPolyfill(globalObject, callbackWithRelease, ms, ...rest);
+        return timeoutId;
     }
     destroy(timeout) {
         clearTimeout(timeout);
     }
 }
-function webSetIntervalPolyfill(callback, ms, ...args) {
+function webSetIntervalPolyfill(globalObject, callback, ms, ...args) {
     return setInterval(()=>{
         // node's `setInterval` sets `this` to the `Timeout` instance it returned,
         // but web `setInterval` always sets `this` to `window`
         // see: https://developer.mozilla.org/en-US/docs/Web/API/Window/setInterval#the_this_problem
-        return callback.apply(globalThis, args);
+        return callback.apply(globalObject, args);
     }, ms)[Symbol.toPrimitive]();
 }
-function webSetTimeoutPolyfill(callback, ms, ...args) {
+function webSetTimeoutPolyfill(globalObject, callback, ms, ...args) {
     const wrappedCallback = ()=>{
         try {
             // node's `setTimeout` sets `this` to the `Timeout` instance it returned,
             // but web `setTimeout` always sets `this` to `window`
             // see: https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout#the_this_problem
-            return callback.apply(globalThis, args);
+            return callback.apply(globalObject, args);
         } finally{
             // On certain older node versions (<20.16.0, <22.4.0),
             // a `setTimeout` whose Timeout was converted to a primitive will leak.

package/dist/node_modules/next/dist/server/web/spec-extension/adapters/headers.js

@@ -24,11 +24,76 @@ const _reflect = require("./reflect");
 class ReadonlyHeadersError extends Error {
     constructor(){
         super('Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers');
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1176",
+            enumerable: false,
+            configurable: true
+        });
     }
     static callable() {
         throw new ReadonlyHeadersError();
     }
 }
+/**
+ * Builds the read methods for a sealed view that exposes all of `target`.
+ */ function createPassThroughMethods(target, sealed) {
+    return {
+        get: target.get.bind(target),
+        has: target.has.bind(target),
+        getSetCookie: target.getSetCookie.bind(target),
+        keys: target.keys.bind(target),
+        values: target.values.bind(target),
+        entries: target.entries.bind(target),
+        [Symbol.iterator]: target[Symbol.iterator].bind(target),
+        // The native method passes the unsealed target as the callback's `parent`
+        // argument. That is a mutable handle on the underlying headers. Pass the
+        // sealed view instead.
+        forEach (callbackfn, thisArg) {
+            for (const [name, value] of target.entries()){
+                callbackfn.call(thisArg, value, name, sealed);
+            }
+        }
+    };
+}
+/**
+ * Builds the read methods for a sealed view that omits the header names matched
+ * by `isHidden`.
+ */ function createHidingMethods(target, sealed, isHidden) {
+    function* entries() {
+        for (const entry of target.entries()){
+            if (!isHidden(entry[0])) {
+                yield entry;
+            }
+        }
+    }
+    return {
+        entries,
+        [Symbol.iterator]: entries,
+        get: (name)=>isHidden(name) ? null : target.get(name),
+        has: (name)=>isHidden(name) ? false : target.has(name),
+        getSetCookie: ()=>isHidden('set-cookie') ? [] : target.getSetCookie(),
+        *keys () {
+            for (const name of target.keys()){
+                if (!isHidden(name)) {
+                    yield name;
+                }
+            }
+        },
+        *values () {
+            for (const [, value] of entries()){
+                yield value;
+            }
+        },
+        // The native method passes the unsealed target as the callback's `parent`
+        // argument. That is a mutable handle on the underlying headers. Pass the
+        // sealed view instead.
+        forEach (callbackfn, thisArg) {
+            for (const [name, value] of entries()){
+                callbackfn.call(thisArg, value, name, sealed);
+            }
+        }
+    };
+}
 class HeadersAdapter extends Headers {
     constructor(headers){
         // We've already overridden the methods that would be called, so we're just
@@ -93,19 +158,55 @@ class HeadersAdapter extends Headers {
     /**
    * Seals a Headers instance to prevent modification by throwing an error when
    * any mutating method is called.
-   */ static seal(headers) {
-        return new Proxy(headers, {
+   *
+   * The sealed view stays live. Later writes to `headers` remain visible
+   * through it.
+   *
+   * `hidden` omits the given header names from every read operation (`get`,
+   * `has`, `getSetCookie`, `forEach`, and iteration). The names must be
+   * lowercase. The underlying headers are neither copied nor mutated, so hidden
+   * headers remain available to the framework.
+   */ static seal(headers, hidden) {
+        const isHidden = hidden && hidden.size > 0 ? (name)=>hidden.has(name.toLowerCase()) : null;
+        // The methods are built once per sealed view and reused, so repeated access
+        // returns the same function instead of a fresh closure. They are assigned
+        // after the proxy exists because `forEach` hands the proxy to its callback.
+        // Creating the proxy runs no trap, so nothing can read them before then.
+        let methods;
+        const sealed = new Proxy(headers, {
             get (target, prop, receiver) {
                 switch(prop){
                     case 'append':
                     case 'delete':
                     case 'set':
                         return ReadonlyHeadersError.callable;
+                    case Symbol.iterator:
+                        return methods[Symbol.iterator];
+                    case 'get':
+                    case 'has':
+                    case 'getSetCookie':
+                    case 'keys':
+                    case 'values':
+                    case 'entries':
+                    case 'forEach':
+                        return methods[prop];
                     default:
                         return _reflect.ReflectAdapter.get(target, prop, receiver);
                 }
             }
         });
+        methods = isHidden ? createHidingMethods(headers, sealed, isHidden) : createPassThroughMethods(headers, sealed);
+        return sealed;
+    }
+    /**
+   * @param headers
+   * @returns A fresh object identity backed by the original value
+   */ static fresh(headers) {
+        return new Proxy(headers, {
+            get (target, prop, receiver) {
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+        });
     }
     /**
    * Merges a header value into a string. This stores multiple values as an

package/dist/node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js

@@ -51,6 +51,11 @@ const _actionrevalidationkind = require("../../../../shared/lib/action-revalidat
 class ReadonlyRequestCookiesError extends Error {
     constructor(){
         super('Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options');
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1180",
+            enumerable: false,
+            configurable: true
+        });
     }
     static callable() {
         throw new ReadonlyRequestCookiesError();
@@ -71,6 +76,16 @@ class RequestCookiesAdapter {
             }
         });
     }
+    /**
+   * @param cookies
+   * @returns A fresh object identity backed by the original value
+   */ static fresh(cookies) {
+        return new Proxy(cookies, {
+            get (target, prop, receiver) {
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+        });
+    }
 }
 const SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for('next.mutated.cookies');
 function getModifiedCookieValues(cookies) {

package/dist/node_modules/next/dist/server/web/spec-extension/revalidate.js

@@ -37,12 +37,18 @@ const _hooksservercontext = require("../../../client/components/hooks-server-con
 const _invarianterror = require("../../../shared/lib/invariant-error");
 const _actionrevalidationkind = require("../../../shared/lib/action-revalidation-kind");
 const _removetrailingslash = require("../../../shared/lib/router/utils/remove-trailing-slash");
+const _encodeheadersafe = require("../../lib/encode-header-safe");
+const _cachelifeprofile = require("../../use-cache/cache-life-profile");
 function revalidateTag(tag, profile) {
     if (!profile) {
         console.warn('"revalidateTag" without the second argument is now deprecated, add second argument of "max" or use "updateTag". See more info here: https://nextjs.org/docs/messages/revalidate-tag-single-arg');
+    } else if (typeof profile === 'object') {
+        profile = (0, _cachelifeprofile.validateAndNormalizeCacheLifeProfile)(profile, {
+            kind: 'inline'
+        });
     }
     return revalidate([
-        tag
+        (0, _encodeheadersafe.encodeHeaderSafe)(tag)
     ], `revalidateTag ${tag}`, profile);
 }
 function updateTag(tag) {
@@ -58,7 +64,7 @@ function updateTag(tag) {
     }
     // updateTag uses immediate expiration (no profile) without deprecation warning
     return revalidate([
-        tag
+        (0, _encodeheadersafe.encodeHeaderSafe)(tag)
     ], `updateTag ${tag}`, undefined);
 }
 function refresh() {
@@ -82,7 +88,7 @@ function revalidatePath(originalPath, type) {
         console.warn(`Warning: revalidatePath received "${originalPath}" which exceeded max length of ${_constants.NEXT_CACHE_SOFT_TAG_MAX_LENGTH}. See more info here https://nextjs.org/docs/app/api-reference/functions/revalidatePath`);
         return;
     }
-    let normalizedPath = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${(0, _removetrailingslash.removeTrailingSlash)(originalPath)}`;
+    let normalizedPath = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${(0, _encodeheadersafe.encodeHeaderSafe)((0, _removetrailingslash.removeTrailingSlash)(originalPath))}`;
     if (type) {
         normalizedPath += `${normalizedPath.endsWith('/') ? '' : '/'}${type}`;
     } else if ((0, _utils.isDynamicRoute)(originalPath)) {
@@ -99,7 +105,6 @@ function revalidatePath(originalPath, type) {
     return revalidate(tags, `revalidatePath ${originalPath}`);
 }
 function revalidate(tags, expression, profile) {
-    var _store_cacheLifeProfiles;
     const store = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!store || !store.incrementalCache) {
         throw Object.defineProperty(new Error(`Invariant: static generation store missing in ${expression}`), "__NEXT_ERROR_CODE", {
@@ -182,6 +187,7 @@ function revalidate(tags, expression, profile) {
     if (!store.pendingRevalidatedTags) {
         store.pendingRevalidatedTags = [];
     }
+    const revalidatedAt = performance.timeOrigin + performance.now();
     for (const tag of tags){
         const existingIndex = store.pendingRevalidatedTags.findIndex((item)=>{
             if (item.tag !== tag) return false;
@@ -197,14 +203,20 @@ function revalidate(tags, expression, profile) {
         if (existingIndex === -1) {
             store.pendingRevalidatedTags.push({
                 tag,
-                profile
+                profile,
+                revalidatedAt
             });
+        } else {
+            // Revalidating a tag again invalidates everything produced up to now, so
+            // the latest revalidation is the one that decides which entries are
+            // stale.
+            store.pendingRevalidatedTags[existingIndex].revalidatedAt = revalidatedAt;
         }
     }
     // if profile is provided and this is a stale-while-revalidate
     // update we do not mark the path as revalidated so that server
     // actions don't pull their own writes
-    const cacheLife = profile && typeof profile === 'object' ? profile : profile && typeof profile === 'string' && (store == null ? void 0 : (_store_cacheLifeProfiles = store.cacheLifeProfiles) == null ? void 0 : _store_cacheLifeProfiles[profile]) ? store.cacheLifeProfiles[profile] : undefined;
+    const cacheLife = profile && typeof profile === 'object' ? profile : profile && typeof profile === 'string' && (store == null ? void 0 : store.cacheLifeProfiles[profile]) ? store.cacheLifeProfiles[profile] : undefined;
     if (!profile || (cacheLife == null ? void 0 : cacheLife.expire) === 0) {
         // TODO: only revalidate if the path matches
         store.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;

package/dist/node_modules/next/dist/server/web/spec-extension/unstable-cache.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "unstable_cache", {
 });
 const _constants = require("../../../lib/constants");
 const _patchfetch = require("../../lib/patch-fetch");
+const _encodeheadersafe = require("../../lib/encode-header-safe");
 const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
 const _responsecache = require("../../response-cache");
@@ -43,8 +44,10 @@ function unstable_cache(cb, keyParts, options = {}) {
     }
     // Validate the tags provided are valid
     const tags = options.tags ? (0, _patchfetch.validateTags)(options.tags, `unstable_cache ${cb.toString()}`) : [];
-    // Validate the revalidate options
-    (0, _patchfetch.validateRevalidate)(options.revalidate, `unstable_cache ${cb.name || cb.toString()}`);
+    // Validate the revalidate option, and adopt the normalized value, which
+    // maps `false` and `Infinity` to INFINITE_CACHE so that the stored value
+    // survives JSON serialization.
+    const revalidate = (0, _patchfetch.validateRevalidate)(options.revalidate, `unstable_cache ${cb.name || cb.toString()}`);
     // Stash the fixed part of the key at construction time. The invocation key will combine
     // the fixed key with the arguments when actually called
     // @TODO if cb.toString() is long we should hash it
@@ -80,9 +83,20 @@ function unstable_cache(cb, keyParts, options = {}) {
             // @TODO stringify is likely not safe here. We will coerce undefined to null which will make
             // the keyspace smaller than the execution space
             const invocationKey = `${fixedKey}-${JSON.stringify(args)}`;
-            const cacheKey = await incrementalCache.generateCacheKey(invocationKey);
+            const cacheKey = await incrementalCache.generateSimpleCacheKey(invocationKey);
             // $urlWithPath,$sortedQueryStringKeys,$hashOfEveryThingElse
-            const fetchUrl = `unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`;
+            //
+            // A cache implementation may serialize this name into an HTTP request
+            // header, so it is encoded here. Both parts can carry a character above
+            // U+00FF: the search parameters are decoded, and a JavaScript identifier
+            // may hold one. The character class leaves the separating spaces and the
+            // URL punctuation untouched, so the shape above is preserved.
+            //
+            // `toWellFormed` replaces lone surrogates, which `cb.name` can hold and
+            // which `encodeURIComponent` rejects. The name identifies the call for
+            // debug metrics, so a replacement character is an acceptable trade for
+            // not failing the render.
+            const fetchUrl = (0, _encodeheadersafe.encodeHeaderSafe)(`unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`.toWellFormed());
             const fetchIdx = (workStore ? workStore.nextFetchId : noStoreFetchIdx) ?? 1;
             const implicitTags = workUnitStore == null ? void 0 : workUnitStore.implicitTags;
             const innerCacheStore = {
@@ -106,14 +120,14 @@ function unstable_cache(cb, keyParts, options = {}) {
                         case 'prerender-runtime':
                         case 'prerender-ppr':
                         case 'prerender-legacy':
-                            // We update the store's revalidate property if the option.revalidate is a higher precedence
-                            // options.revalidate === undefined doesn't affect timing.
-                            // options.revalidate === false doesn't shrink timing. it stays at the maximum.
-                            if (typeof options.revalidate === 'number') {
-                                if (workUnitStore.revalidate < options.revalidate) {
+                            // We update the store's revalidate property if the revalidate option is a higher precedence
+                            // revalidate === undefined doesn't affect timing.
+                            // revalidate === INFINITE_CACHE (from `false` or `Infinity`) doesn't shrink timing. it stays at the maximum.
+                            if (typeof revalidate === 'number') {
+                                if (workUnitStore.revalidate < revalidate) {
                                 // The store is already revalidating on a shorter time interval, leave it alone
                                 } else {
-                                    workUnitStore.revalidate = options.revalidate;
+                                    workUnitStore.revalidate = revalidate;
                                 }
                             }
                             // We need to accumulate the tags for this invocation within the store
@@ -147,7 +161,7 @@ function unstable_cache(cb, keyParts, options = {}) {
                     // We attempt to get the current cache entry from the incremental cache.
                     const cacheEntry = await incrementalCache.get(cacheKey, {
                         kind: _responsecache.IncrementalCacheKind.FETCH,
-                        revalidate: options.revalidate,
+                        revalidate,
                         tags,
                         softTags: implicitTags == null ? void 0 : implicitTags.tags,
                         fetchIdx,
@@ -174,7 +188,7 @@ function unstable_cache(cb, keyParts, options = {}) {
                                 if (!workStore.pendingRevalidates[invocationKey]) {
                                     // Create the revalidation promise
                                     const revalidationPromise = _workunitasyncstorageexternal.workUnitAsyncStorage.run(innerCacheStore, cb, ...args).then(async (result)=>{
-                                        await cacheNewResult(result, incrementalCache, cacheKey, tags, options.revalidate, fetchIdx, fetchUrl);
+                                        await cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl);
                                         return result;
                                     }).catch((err)=>{
                                         // @TODO This error handling seems wrong. We swallow the error?
@@ -192,8 +206,12 @@ function unstable_cache(cb, keyParts, options = {}) {
                                 // Check if we need to do foreground revalidation
                                 if (workStore.isStaticGeneration) {
                                     // When the page is revalidating and the cache entry is stale,
-                                    // we need to wait for fresh data (blocking revalidate)
-                                    return workStore.pendingRevalidates[invocationKey];
+                                    // we need to wait for fresh data (blocking revalidate). The
+                                    // `await` here keeps `cacheSignal.endRead` (in the outer
+                                    // `finally`) suspended until the recompute + cacheNewResult
+                                    // actually complete, so the prospective prerender's
+                                    // `cacheSignal` doesn't resolve `cacheReady` prematurely.
+                                    return await workStore.pendingRevalidates[invocationKey];
                                 }
                             // Otherwise, we're doing background revalidation - return stale immediately
                             }
@@ -211,7 +229,7 @@ function unstable_cache(cb, keyParts, options = {}) {
                     // We need to push the cache result promise to pending
                     // revalidates otherwise it won't be awaited and is just
                     // dangling
-                    workStore.pendingRevalidates[invocationKey] = cacheNewResult(result, incrementalCache, cacheKey, tags, options.revalidate, fetchIdx, fetchUrl);
+                    workStore.pendingRevalidates[invocationKey] = cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl);
                 }
                 return result;
             } else {
@@ -224,7 +242,7 @@ function unstable_cache(cb, keyParts, options = {}) {
                     // We aren't doing an on demand revalidation so we check use the cache if valid
                     const cacheEntry = await incrementalCache.get(cacheKey, {
                         kind: _responsecache.IncrementalCacheKind.FETCH,
-                        revalidate: options.revalidate,
+                        revalidate,
                         tags,
                         fetchIdx,
                         fetchUrl,
@@ -249,7 +267,7 @@ function unstable_cache(cb, keyParts, options = {}) {
                 // we need to wait setting the new cache result here as
                 // we don't have pending revalidates on workStore to
                 // push to and we can't have a dangling promise
-                await cacheNewResult(result, incrementalCache, cacheKey, tags, options.revalidate, fetchIdx, fetchUrl);
+                await cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl);
                 return result;
             }
         } finally{

package/dist/node_modules/next/dist/server/web/spec-extension/url-pattern.js

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "URLPattern", {
         return GlobalURLPattern;
     }
 });
-const GlobalURLPattern = // @ts-expect-error: URLPattern is not available in Node.js
-typeof URLPattern === 'undefined' ? undefined : URLPattern;
+const GlobalURLPattern = typeof URLPattern === 'undefined' ? undefined : URLPattern;
 
 //# sourceMappingURL=url-pattern.js.map