@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/app-render/encryption-utils.js

@@ -77,11 +77,7 @@ async function getActionEncryptionKey() {
     const serverActionsManifest = (0, _manifestssingleton.getServerActionsManifest)();
     const rawKey = process.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY || serverActionsManifest.encryptionKey;
     if (rawKey === undefined) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Missing encryption key for Server Actions'), "__NEXT_ERROR_CODE", {
-            value: "E571",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('Missing encryption key for Server Actions');
     }
     __next_loaded_action_key = await crypto.subtle.importKey('raw', stringToUint8Array(atob(rawKey)), 'AES-GCM', true, [
         'encrypt',

package/app/node_modules/next/dist/server/app-render/instant-validation/boundary-tracking.js

@@ -20,9 +20,9 @@ _export(exports, {
         return createValidationBoundaryTracking;
     }
 });
-function createValidationBoundaryTracking() {
+function createValidationBoundaryTracking(/** Pass if the render is expected to render the same IDs as a previous one. */ matchPrevious) {
     return {
-        requiredIds: new Map(),
+        requiredIds: matchPrevious ? new Map(matchPrevious.requiredIds) : new Map(),
         renderedIds: new Set()
     };
 }

package/app/node_modules/next/dist/server/app-render/instant-validation/instant-config.js

@@ -48,7 +48,7 @@ const _workasyncstorageexternal = require("../work-async-storage.external");
 const _invarianterror = require("../../../shared/lib/invariant-error");
 function isImplicitValidationSegment(segment) {
     const key = typeof segment === 'string' ? segment : segment[0];
-    return key === _segment.PAGE_SEGMENT_KEY || key.startsWith(_segment.PAGE_SEGMENT_KEY) || key === _segment.DEFAULT_SEGMENT_KEY;
+    return key === _segment.PAGE_SEGMENT_KEY || key === _segment.DEFAULT_SEGMENT_KEY;
 }
 function isFrameworkErrorRoute(route) {
     return route === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE || route === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE;
@@ -57,7 +57,7 @@ async function anySegmentHasPartialPrefetchingEnabled(tree) {
     const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
     // TODO(restart-on-cache-miss): Does this work correctly for client page/layout modules?
     const prefetchConfig = layoutOrPageMod ? layoutOrPageMod.prefetch : undefined;
-    if (prefetchConfig === 'partial' || prefetchConfig === 'unstable_eager') {
+    if (prefetchConfig === 'partial') {
         return true;
     }
     const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
@@ -112,11 +112,7 @@ var VALIDATION_LEVEL = /*#__PURE__*/ function(VALIDATION_LEVEL) {
  */ async function anySegmentNeedsInstantValidation(rootTree, level) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('anySegmentNeedsInstantValidation must run inside a WorkStore'), "__NEXT_ERROR_CODE", {
-            value: "E1185",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('anySegmentNeedsInstantValidation must run inside a WorkStore');
     }
     const { validationLevel } = workStore;
     let baseValidationLevel = 0;
@@ -218,11 +214,7 @@ const resolveInstantConfigSamplesForPage = async (tree)=>{
     return (arg)=>{
         const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
         if (!workStore) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`${func.name || 'cacheScopedToWorkStore callee'} must run inside a WorkStore`), "__NEXT_ERROR_CODE", {
-                value: "E1186",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`${func.name || 'cacheScopedToWorkStore callee'} must run inside a WorkStore`);
         }
         let results = resultsPerWorkStore.get(workStore);
         if (results && results.has(arg)) {

package/app/node_modules/next/dist/server/app-render/instant-validation/instant-samples.js

@@ -84,22 +84,17 @@ function getExpectedSampleTracking() {
             case 'private-cache':
             case 'unstable-cache':
             case 'prerender-legacy':
-            case 'prerender-ppr':
             case 'prerender-client':
             case 'prerender':
             case 'prerender-runtime':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;
         }
     }
     if (!validationSampleTracking) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected to have a workUnitStore that provides validationSampleTracking'), "__NEXT_ERROR_CODE", {
-            value: "E1110",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('Expected to have a workUnitStore that provides validationSampleTracking');
     }
     return validationSampleTracking;
 }
@@ -162,11 +157,7 @@ function createCookiesFromSample(sampleCookies, route) {
     });
 }
 function createMissingCookieSampleError(route, name) {
-    return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed cookie "${name}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`cookies\` array, ` + `or \`{ name: "${name}", value: null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
-        value: "E1346",
-        enumerable: false,
-        configurable: true
-    });
+    return new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed cookie "${name}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`cookies\` array, ` + `or \`{ name: "${name}", value: null }\` if it should be absent.`);
 }
 function createHeadersFromSample(rawSampleHeaders, sampleCookies, route) {
     // If we have cookie samples, add a `cookie` header to match.
@@ -176,11 +167,7 @@ function createHeadersFromSample(rawSampleHeaders, sampleCookies, route) {
         ...rawSampleHeaders
     ] : [];
     if (sampleHeaders.find(([name])=>name.toLowerCase() === 'cookie')) {
-        throw Object.defineProperty(new _instantvalidationerror.InstantValidationError('Invalid sample: Defining cookies via a "cookie" header is not supported. Use `cookies: [{ name: ..., value: ... }]` instead.'), "__NEXT_ERROR_CODE", {
-            value: "E1111",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _instantvalidationerror.InstantValidationError('Invalid sample: Defining cookies via a "cookie" header is not supported. Use `cookies: [{ name: ..., value: ... }]` instead.');
     }
     if (sampleCookies) {
         const cookieHeaderValue = sampleCookies.toString();
@@ -207,11 +194,7 @@ function createHeadersFromSample(rawSampleHeaders, sampleCookies, route) {
                 const patchedMethod = function(rawName) {
                     const name = rawName.toLowerCase();
                     if (!declaredNames.has(name)) {
-                        trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed header "${name}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`headers\` array, ` + `or \`["${name}", null]\` if it should be absent.`), "__NEXT_ERROR_CODE", {
-                            value: "E1348",
-                            enumerable: false,
-                            configurable: true
-                        }));
+                        trackMissingSampleErrorAndThrow(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed header "${name}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`headers\` array, ` + `or \`["${name}", null]\` if it should be absent.`));
                     }
                     // typescript can't reconcile a union of functions with a union of return types,
                     // so we have to cast the original return type away
@@ -233,18 +216,10 @@ function createDraftModeForValidation() {
             return false;
         },
         enable () {
-            throw Object.defineProperty(new Error('Draft mode cannot be enabled during build-time instant validation.'), "__NEXT_ERROR_CODE", {
-                value: "E1092",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Draft mode cannot be enabled during build-time instant validation.');
         },
         disable () {
-            throw Object.defineProperty(new Error('Draft mode cannot be disabled during build-time instant validation.'), "__NEXT_ERROR_CODE", {
-                value: "E1094",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Draft mode cannot be disabled during build-time instant validation.');
         }
     };
 }
@@ -254,11 +229,7 @@ function createExhaustiveParamsProxy(underlyingParams, declaredParamNames, route
             if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop) && // Only error when accessing a param that is part of the route but wasn't provided.
             // accessing properties that aren't expected to be a valid param value is fine.
             prop in underlyingParams && !declaredParamNames.has(prop)) {
-                trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed param "${prop}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
-                    value: "E1349",
-                    enumerable: false,
-                    configurable: true
-                }));
+                trackMissingSampleErrorAndThrow(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed param "${prop}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`params\` object.`));
             }
             return Reflect.get(target, prop, receiver);
         }
@@ -303,11 +274,7 @@ function createExhaustiveURLSearchParamsProxy(searchParams, declaredSearchParamN
     });
 }
 function createMissingSearchParamSampleError(route, name) {
-    return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed searchParam "${name}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`searchParams\` object, ` + `or \`{ "${name}": null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
-        value: "E1347",
-        enumerable: false,
-        configurable: true
-    });
+    return new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed searchParam "${name}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`searchParams\` object, ` + `or \`{ "${name}": null }\` if it should be absent.`);
 }
 function createRelativeURLFromSamples(route, sampleParams, sampleSearchParams) {
     // Build searchParams query object and URL search string from sample
@@ -361,11 +328,7 @@ function createURLSearchParamsFromSample(sampleSearchParams) {
                             ];
                         } else if (!Array.isArray(paramValue)) {
                             // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`
-                            throw Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be an array of strings, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
-                                value: "E1104",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be an array of strings, got ${typeof paramValue}`);
                         }
                         interpolatedSegments.push(...paramValue.map((v)=>encodeURIComponent(v)));
                         break;
@@ -380,11 +343,7 @@ function createURLSearchParamsFromSample(sampleSearchParams) {
                             paramValue = rawSegment;
                         } else if (typeof paramValue !== 'string') {
                             // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`
-                            throw Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be a string, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
-                                value: "E1108",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be a string, got ${typeof paramValue}`);
                         }
                         interpolatedSegments.push(encodeURIComponent(paramValue));
                         break;
@@ -399,11 +358,7 @@ function createURLSearchParamsFromSample(sampleSearchParams) {
                 case 'dynamic-intercepted-(...)':
                     {
                         // TODO(instant-validation-build): i don't know how these are supposed to work, or if we can even get them here
-                        throw Object.defineProperty(new _invarianterror.InvariantError('Not implemented: Validation of interception routes'), "__NEXT_ERROR_CODE", {
-                            value: "E1106",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new _invarianterror.InvariantError('Not implemented: Validation of interception routes');
                     }
                 default:
                     {
@@ -421,11 +376,7 @@ function assertRootParamInSamples(workStore, sampleParams, paramName) {
     // The param is defined in the samples.
     } else {
         const route = workStore.route;
-        trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed root param "${paramName}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
-            value: "E1192",
-            enumerable: false,
-            configurable: true
-        }));
+        trackMissingSampleErrorAndThrow(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed root param "${paramName}" which is not defined in the \`unstable_samples\` ` + `of \`instant\`. Add it to the sample's \`params\` object.`));
     }
 }
 

package/app/node_modules/next/dist/server/app-render/instant-validation/stream-utils.js

@@ -23,11 +23,7 @@ _export(exports, {
 const _invarianterror = require("../../../shared/lib/invariant-error");
 function createNodeStreamWithLateRelease(partialChunks, allChunks, releaseSignal) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamWithLateRelease cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E993",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('createNodeStreamWithLateRelease cannot be used in the edge runtime');
     } else {
         const { Readable } = require('node:stream');
         let nextIndex = 0;
@@ -62,11 +58,7 @@ function createNodeStreamWithLateRelease(partialChunks, allChunks, releaseSignal
 }
 function createNodeStreamFromChunks(chunks, signal) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamFromChunks cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E945",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('createNodeStreamFromChunks cannot be used in the edge runtime');
     } else {
         const { Readable } = require('node:stream');
         // If there's a signal, delay closing until it fires

package/app/node_modules/next/dist/server/app-render/manifests-singleton.js

@@ -6,8 +6,10 @@ Object.defineProperty(exports, "__esModule", {
     getActionNotFoundError: null,
     getClientReferenceManifest: null,
     getInvalidServerReferenceIdError: null,
+    getRscModuleMappingForUseCache: null,
     getServerActionsManifest: null,
     getServerModuleMap: null,
+    normalizeWorkerPageName: null,
     selectWorkerForForwarding: null,
     setManifestsSingleton: null
 });
@@ -27,12 +29,18 @@ _export(exports, {
     getInvalidServerReferenceIdError: function() {
         return getInvalidServerReferenceIdError;
     },
+    getRscModuleMappingForUseCache: function() {
+        return getRscModuleMappingForUseCache;
+    },
     getServerActionsManifest: function() {
         return getServerActionsManifest;
     },
     getServerModuleMap: function() {
         return getServerModuleMap;
     },
+    normalizeWorkerPageName: function() {
+        return normalizeWorkerPageName;
+    },
     selectWorkerForForwarding: function() {
         return selectWorkerForForwarding;
     },
@@ -47,12 +55,9 @@ const _removepathprefix = require("../../shared/lib/router/utils/remove-path-pre
 const _serverreferenceinfo = require("../../shared/lib/server-reference-info");
 const _reflectutils = require("../../shared/lib/utils/reflect-utils");
 const _workasyncstorageexternal = require("./work-async-storage.external");
+const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
 function getActionNotFoundError(actionId) {
-    return Object.defineProperty(new Error(`Failed to find Server Action${actionId ? ` "${actionId}"` : ''}. This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
-        value: "E974",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`Failed to find Server Action${actionId ? ` "${actionId}"` : ''}. This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`);
 }
 function getInvalidServerReferenceIdError(id) {
     // `id` is arbitrary client-provided input. Unlike the not-found case, it has
@@ -63,11 +68,7 @@ function getInvalidServerReferenceIdError(id) {
     // flooding. Ids at or below the cap are logged in full so that we only add an
     // ellipsis to ids that are meaningfully longer than the truncated length.
     const encoded = JSON.stringify(id.length > MAX_LOGGED_SERVER_REFERENCE_ID_LENGTH ? id.slice(0, TRUNCATED_SERVER_REFERENCE_ID_LENGTH) + '…' : id);
-    return Object.defineProperty(new Error(`The Server Reference ID did not match the expected format. Received ${encoded}.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
-        value: "E1442",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`The Server Reference ID did not match the expected format. Received ${encoded}.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`);
 }
 // Ids at or below the cap are logged in full. Longer ids are truncated to the
 // shorter length and marked with an ellipsis, so the cap leaves headroom over
@@ -79,6 +80,27 @@ const TRUNCATED_SERVER_REFERENCE_ID_LENGTH = 90;
 // AsyncLocalStorage as it might happen at the module level.
 const MANIFESTS_SINGLETON = Symbol.for('next.server.manifests');
 const globalThisWithManifests = globalThis;
+function isUseCacheStore(workUnitStore) {
+    if (!workUnitStore) {
+        return false;
+    }
+    switch(workUnitStore.type){
+        case 'cache':
+        case 'private-cache':
+            return true;
+        case 'request':
+        case 'unstable-cache':
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-legacy':
+        case 'prerender-runtime':
+        case 'validation-client':
+        case 'build-time-generator':
+            return false;
+        default:
+            return workUnitStore;
+    }
+}
 function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute) {
     const createMappingProxy = (prop)=>{
         return new Proxy({}, {
@@ -88,6 +110,38 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
                     var _clientReferenceManifestsPerRoute_get;
                     const currentManifest = (_clientReferenceManifestsPerRoute_get = clientReferenceManifestsPerRoute.get(workStore.route)) == null ? void 0 : _clientReferenceManifestsPerRoute_get.clientReferenceManifest;
                     if (currentManifest == null ? void 0 : currentManifest[prop][id]) {
+                        if (workStore.durableUseCacheEntries && prop === 'clientModules') {
+                            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+                            if (isUseCacheStore(workUnitStore)) {
+                                // This creates a mapping so that a given client references with name
+                                // `app/foo/client.tsx` is serialized as
+                                // ```
+                                // { id: `app/foo/client.tsx`, name: `*`, chunks: ["stub"], async: false }
+                                // ```
+                                // instead of the actual
+                                // ```
+                                // { id: 19132, name: `*`, chunks: ["/_next/static/chunks/..."], async: true }
+                                // ```
+                                //
+                                // This means that not the unstable client module id is used for the cache entry,
+                                // but the stable client reference name. The stable client reference name is
+                                // resolved against the current manifest via rscModuleMappingForUseCache when the
+                                // entry is read.
+                                const clientReferenceManifestEntry = currentManifest.clientModules[id];
+                                return {
+                                    // Return `id` instead of `clientReferenceManifestEntry.id` here.
+                                    id,
+                                    name: clientReferenceManifestEntry.name,
+                                    // Set a sentinel value just in case this does ends up being read at some point
+                                    // in the future, then at least we'll get "Failed to load chunk stub (404)"
+                                    // instead of "Failed to load module 1234".
+                                    chunks: [
+                                        'stub'
+                                    ],
+                                    async: false
+                                };
+                            }
+                        }
                         return currentManifest[prop][id];
                     }
                     // In development, we also check all other manifests to see if the
@@ -137,7 +191,7 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
         });
     };
     const mappingProxies = new Map();
-    return new Proxy({}, {
+    const proxiedClientReferenceManifest = new Proxy({}, {
         get (_, prop) {
             const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
             switch(prop){
@@ -146,19 +200,11 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
                 case 'entryJSFiles':
                     {
                         if (!workStore) {
-                            throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot access "${prop}" without a work store.`), "__NEXT_ERROR_CODE", {
-                                value: "E952",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new _invarianterror.InvariantError(`Cannot access "${prop}" without a work store.`);
                         }
                         const registeredManifest = clientReferenceManifestsPerRoute.get(workStore.route);
                         if (!registeredManifest) {
-                            throw Object.defineProperty(new _invarianterror.InvariantError(`The client reference manifest for route "${workStore.route}" does not exist.`), "__NEXT_ERROR_CODE", {
-                                value: "E951",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new _invarianterror.InvariantError(`The client reference manifest for route "${workStore.route}" does not exist.`);
                         }
                         return registeredManifest.clientReferenceManifest[prop];
                     }
@@ -177,15 +223,43 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
                     }
                 default:
                     {
-                        throw Object.defineProperty(new _invarianterror.InvariantError(`This is a proxied client reference manifest. The property "${String(prop)}" is not handled.`), "__NEXT_ERROR_CODE", {
-                            value: "E953",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new _invarianterror.InvariantError(`This is a proxied client reference manifest. The property "${String(prop)}" is not handled.`);
                     }
             }
         }
     });
+    // Performs the inverse of the clientModules isUseCacheStore(workUnitStore) special case above:
+    //
+    // For cache functions, don't do the usual rscModuleMapping lookup by module ID, but instead look
+    // up by the stable client reference name. This is because cache entries must not depend on
+    // build-local module IDs or chunks. So we need a second layer of indirection here to do client
+    // reference name -> client module id -> rsc module mapping lookup.
+    //
+    // This one is created separately (not inside proxiedClientReferenceManifest.rscModuleMapping) as
+    // we don't necessarily are inside a workUnitStore when we need to access this mapping (as opposed
+    // to the clientModules mapping, which always has the ALS set).
+    const rscModuleMappingForUseCache = new Proxy({}, {
+        get (_, key) {
+            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+            if (workStore && workStore.durableUseCacheEntries) {
+                var _clientReferenceManifestsPerRoute_get;
+                const currentManifest = (_clientReferenceManifestsPerRoute_get = clientReferenceManifestsPerRoute.get(workStore.route)) == null ? void 0 : _clientReferenceManifestsPerRoute_get.clientReferenceManifest;
+                const clientReferenceName = key;
+                const clientReferenceManifestEntry = currentManifest == null ? void 0 : currentManifest.clientModules[clientReferenceName];
+                if (clientReferenceManifestEntry === undefined) {
+                    return undefined;
+                }
+                const clientModuleId = clientReferenceManifestEntry.id;
+                return currentManifest == null ? void 0 : currentManifest.rscModuleMapping[clientModuleId];
+            } else {
+                return proxiedClientReferenceManifest.rscModuleMapping[key];
+            }
+        }
+    });
+    return {
+        proxiedClientReferenceManifest,
+        rscModuleMappingForUseCache
+    };
 }
 /**
  * This function creates a Flight-acceptable server module map proxy from our
@@ -228,20 +302,18 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
             if (!workerEntry) {
                 throw getActionNotFoundError(id);
             }
-            const { moduleId, async } = workerEntry;
+            const { moduleId, async, durability } = workerEntry;
             return {
                 id: moduleId,
                 name: id,
                 chunks: [],
-                async
+                async,
+                durability
             };
         }
     });
 }
-/**
- * The flight entry loader keys actions by bundlePath. bundlePath corresponds
- * with the relative path (including 'app') to the page entrypoint.
- */ function normalizeWorkerPageName(pageName) {
+function normalizeWorkerPageName(pageName) {
     if ((0, _pathhasprefix.pathHasPrefix)(pageName, 'app')) {
         return pageName;
     }
@@ -294,10 +366,11 @@ function setManifestsSingleton({ page, clientReferenceManifest, serverActionsMan
                 }
             ]
         ]);
-        const proxiedClientReferenceManifest = createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute);
+        const { proxiedClientReferenceManifest, rscModuleMappingForUseCache } = createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute);
         globalThisWithManifests[MANIFESTS_SINGLETON] = {
             clientReferenceManifestsPerRoute,
             proxiedClientReferenceManifest,
+            rscModuleMappingForUseCache,
             serverActionsManifest,
             serverModuleMap: createServerModuleMap()
         };
@@ -306,17 +379,16 @@ function setManifestsSingleton({ page, clientReferenceManifest, serverActionsMan
 function getManifestsSingleton() {
     const manifestSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
     if (!manifestSingleton) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('The manifests singleton was not initialized.'), "__NEXT_ERROR_CODE", {
-            value: "E950",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('The manifests singleton was not initialized.');
     }
     return manifestSingleton;
 }
 function getClientReferenceManifest() {
     return getManifestsSingleton().proxiedClientReferenceManifest;
 }
+function getRscModuleMappingForUseCache() {
+    return getManifestsSingleton().rscModuleMappingForUseCache;
+}
 function getServerActionsManifest() {
     return getManifestsSingleton().serverActionsManifest;
 }

package/app/node_modules/next/dist/server/app-render/module-loading/track-module-loading.instance.js

@@ -31,7 +31,7 @@ const _cachesignal = require("../cache-signal");
  */ let _moduleLoadingSignal;
 function getModuleLoadingSignal() {
     if (!_moduleLoadingSignal) {
-        _moduleLoadingSignal = new _cachesignal.CacheSignal();
+        _moduleLoadingSignal = new _cachesignal.CacheSignal(null);
     }
     return _moduleLoadingSignal;
 }

package/app/node_modules/next/dist/server/app-render/parse-and-validate-flight-router-state.js

@@ -15,11 +15,7 @@ function parseAndValidateFlightRouterState(stateHeader) {
         return undefined;
     }
     if (Array.isArray(stateHeader)) {
-        throw Object.defineProperty(new Error('Multiple router state headers were sent. This is not allowed.'), "__NEXT_ERROR_CODE", {
-            value: "E418",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Multiple router state headers were sent. This is not allowed.');
     }
     // We limit the size of the router state header to ~40kb. This is to prevent
     // a malicious user from sending a very large header and slowing down the
@@ -27,22 +23,14 @@ function parseAndValidateFlightRouterState(stateHeader) {
     // This is around 2,000 nested or parallel route segment states:
     // '{"children":["",{}]}'.length === 20.
     if (stateHeader.length > 20 * 2000) {
-        throw Object.defineProperty(new Error('The router state header was too large.'), "__NEXT_ERROR_CODE", {
-            value: "E142",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('The router state header was too large.');
     }
     try {
         const state = JSON.parse(decodeURIComponent(stateHeader));
         (0, _superstruct.assert)(state, _types.flightRouterStateSchema);
         return state;
     } catch  {
-        throw Object.defineProperty(new Error('The router state header was sent but could not be parsed.'), "__NEXT_ERROR_CODE", {
-            value: "E10",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('The router state header was sent but could not be parsed.');
     }
 }