failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/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/.next/standalone/node_modules/next/dist/server/app-render/module-loading/track-dynamic-import.js

@@ -13,19 +13,11 @@ const _isthenable = require("../../../shared/lib/is-thenable");
 const _trackmoduleloadingexternal = require("./track-module-loading.external");
 function trackDynamicImport(modulePromise) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError("Dynamic imports should not be instrumented in the edge runtime, because `cacheComponents` doesn't support it"), "__NEXT_ERROR_CODE", {
-            value: "E687",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError("Dynamic imports should not be instrumented in the edge runtime, because `cacheComponents` doesn't support it");
     }
     if (!(0, _isthenable.isThenable)(modulePromise)) {
         // We're expecting `import()` to always return a promise. If it's not, something's very wrong.
-        throw Object.defineProperty(new _invarianterror.InvariantError('`trackDynamicImport` should always receive a promise. Something went wrong in the dynamic imports transform.'), "__NEXT_ERROR_CODE", {
-            value: "E677",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('`trackDynamicImport` should always receive a promise. Something went wrong in the dynamic imports transform.');
     }
     // Even if we're inside a prerender and have `workUnitStore.cacheSignal`, we always track the promise globally.
     // (i.e. via the global `moduleLoadingSignal` that `trackPendingImport` uses internally).

package/.next/standalone/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/.next/standalone/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.');
     }
 }
 

package/.next/standalone/node_modules/next/dist/server/app-render/postponed-state.js

@@ -9,7 +9,8 @@ Object.defineProperty(exports, "__esModule", {
     getDynamicHTMLPostponedState: null,
     getPostponedFromState: null,
     isEmptyHTMLPrelude: null,
-    parsePostponedState: null
+    parsePostponedState: null,
+    parseResumeDataCacheFromPostponedState: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -38,9 +39,11 @@ _export(exports, {
     },
     parsePostponedState: function() {
         return parsePostponedState;
+    },
+    parseResumeDataCacheFromPostponedState: function() {
+        return parseResumeDataCacheFromPostponedState;
     }
 });
-const _getdynamicparam = require("../../shared/lib/router/utils/get-dynamic-param");
 const _resumedatacache = require("../resume-data-cache/resume-data-cache");
 var DynamicState = /*#__PURE__*/ function(DynamicState) {
     /**
@@ -56,7 +59,21 @@ var DynamicHTMLPreludeState = /*#__PURE__*/ function(DynamicHTMLPreludeState) {
     DynamicHTMLPreludeState[DynamicHTMLPreludeState["Full"] = 1] = "Full";
     return DynamicHTMLPreludeState;
 }({});
-async function getDynamicHTMLPostponedState(postponed, preludeState, fallbackRouteParams, resumeDataCache, isCacheComponentsEnabled) {
+async function serializePostponedState(postponedString, resumeDataCache, isCacheComponentsEnabled, maxPostponedStateSizeBytes, disableResumeDataCacheCompression) {
+    const prefix = `${postponedString.length}:${postponedString}`;
+    let serializedResumeDataCache = await (0, _resumedatacache.stringifyResumeDataCache)(resumeDataCache, isCacheComponentsEnabled);
+    if (!disableResumeDataCacheCompression) {
+        if (maxPostponedStateSizeBytes !== undefined) {
+            const uncompressedPostponedStateByteLength = Buffer.byteLength(prefix) + Buffer.byteLength(serializedResumeDataCache);
+            if (uncompressedPostponedStateByteLength > maxPostponedStateSizeBytes) {
+                console.warn(`The uncompressed postponed state is ${uncompressedPostponedStateByteLength} bytes, which exceeds the configured experimental.maxPostponedStateSize limit of ${maxPostponedStateSizeBytes} bytes. Next.js currently compresses the Resume Data Cache before persisting the postponed state, but this compression will be removed in a future release. Increase experimental.maxPostponedStateSize to ensure this route can still be resumed after that change.`);
+            }
+        }
+        serializedResumeDataCache = (0, _resumedatacache.deflateResumeDataCache)(serializedResumeDataCache);
+    }
+    return prefix + serializedResumeDataCache;
+}
+async function getDynamicHTMLPostponedState(postponed, preludeState, fallbackRouteParams, resumeDataCache, isCacheComponentsEnabled, maxPostponedStateSizeBytes, disableResumeDataCacheCompression = false) {
     const data = [
         preludeState,
         postponed
@@ -66,38 +83,58 @@ async function getDynamicHTMLPostponedState(postponed, preludeState, fallbackRou
     // state as is.
     if (!fallbackRouteParams || fallbackRouteParams.size === 0) {
         // Serialized as `<postponedString.length>:<postponedString><renderResumeDataCache>`
-        return `${dataString.length}:${dataString}${await (0, _resumedatacache.stringifyResumeDataCache)((0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache), isCacheComponentsEnabled)}`;
+        return serializePostponedState(dataString, resumeDataCache, isCacheComponentsEnabled, maxPostponedStateSizeBytes, disableResumeDataCacheCompression);
     }
-    const replacements = Array.from(fallbackRouteParams.entries());
-    const replacementsString = JSON.stringify(replacements);
-    // Serialized as `<replacements.length><replacements><data>`
-    const postponedString = `${replacementsString.length}${replacementsString}${dataString}`;
+    const fallbackParamsString = JSON.stringify(Array.from(fallbackRouteParams.keys()));
+    // Render staging only needs to know which params were unknown. Their opaque
+    // placeholders and types aren't needed to resume, since React's server keys
+    // don't depend on param values.
+    // Serialized as `<fallbackParams.length><fallbackParams><data>`
+    const postponedString = `${fallbackParamsString.length}${fallbackParamsString}${dataString}`;
     // Serialized as `<postponedString.length>:<postponedString><renderResumeDataCache>`
-    return `${postponedString.length}:${postponedString}${await (0, _resumedatacache.stringifyResumeDataCache)(resumeDataCache, isCacheComponentsEnabled)}`;
+    return serializePostponedState(postponedString, resumeDataCache, isCacheComponentsEnabled, maxPostponedStateSizeBytes, disableResumeDataCacheCompression);
 }
-async function getDynamicDataPostponedState(resumeDataCache, isCacheComponentsEnabled) {
-    return `4:null${await (0, _resumedatacache.stringifyResumeDataCache)((0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache), isCacheComponentsEnabled)}`;
+async function getDynamicDataPostponedState(resumeDataCache, isCacheComponentsEnabled, maxPostponedStateSizeBytes, disableResumeDataCacheCompression = false, fallbackRouteParams) {
+    let postponedString = 'null';
+    if (fallbackRouteParams !== undefined) {
+        const fallbackParamsString = JSON.stringify(fallbackRouteParams ? Array.from(fallbackRouteParams.keys()) : []);
+        // Record the unknown param names even when React has no HTML to resume.
+        // An empty array explicitly records that this shell has no fallback params.
+        postponedString = `${fallbackParamsString.length}${fallbackParamsString}null`;
+    }
+    return serializePostponedState(postponedString, resumeDataCache, isCacheComponentsEnabled, maxPostponedStateSizeBytes, disableResumeDataCacheCompression);
 }
-function parsePostponedState(state, interpolatedParams, maxPostponedStateSizeBytes) {
+function parsePostponedStateParts(state, maxPostponedStateSizeBytes, disableResumeDataCacheCompression) {
+    var _state_match;
+    const postponedStringLengthMatch = (_state_match = state.match(/^([0-9]*):/)) == null ? void 0 : _state_match[1];
+    if (!postponedStringLengthMatch) {
+        // Do not include the raw state in the message: it can be large and may
+        // contain sensitive serialized data.
+        throw new Error('Invariant: invalid postponed state: missing length prefix');
+    }
+    const postponedStringLength = parseInt(postponedStringLengthMatch);
+    const tailStart = postponedStringLengthMatch.length + postponedStringLength + 1;
+    return {
+        postponedString: state.slice(postponedStringLengthMatch.length + 1, tailStart),
+        renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(state.slice(tailStart), maxPostponedStateSizeBytes, disableResumeDataCacheCompression)
+    };
+}
+function parseResumeDataCacheFromPostponedState(state, maxPostponedStateSizeBytes, disableResumeDataCacheCompression = false) {
     try {
-        var _state_match;
-        const postponedStringLengthMatch = (_state_match = state.match(/^([0-9]*):/)) == null ? void 0 : _state_match[1];
-        if (!postponedStringLengthMatch) {
-            // Do not include the raw state in the message: it can be large and may
-            // contain sensitive serialized data.
-            throw Object.defineProperty(new Error('Invariant: invalid postponed state: missing length prefix'), "__NEXT_ERROR_CODE", {
-                value: "E1388",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        const postponedStringLength = parseInt(postponedStringLengthMatch);
-        // We add a `:` to the end of the length as the first character of the
-        // postponed string is the length of the replacement entries.
-        const postponedString = state.slice(postponedStringLengthMatch.length + 1, postponedStringLengthMatch.length + postponedStringLength + 1);
-        const renderResumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(state.slice(postponedStringLengthMatch.length + postponedStringLength + 1), maxPostponedStateSizeBytes);
+        return parsePostponedStateParts(state, maxPostponedStateSizeBytes, disableResumeDataCacheCompression).renderResumeDataCache;
+    } catch (err) {
+        console.error('Failed to parse postponed state', describePostponedStateParseFailure(state, err));
+        return (0, _resumedatacache.createRenderResumeDataCache)((0, _resumedatacache.createPrerenderResumeDataCache)());
+    }
+}
+function parsePostponedState(state, maxPostponedStateSizeBytes, disableResumeDataCacheCompression = false) {
+    try {
+        const { postponedString, renderResumeDataCache } = parsePostponedStateParts(state, maxPostponedStateSizeBytes, disableResumeDataCacheCompression);
         try {
             if (postponedString === 'null') {
+                // Leave `stagedFallbackParams` unset for the `4:null<cache>` form. It
+                // contains no fallback-parameter information. A platform can send
+                // `4:nullnull` when it invokes the renderer without a cached shell.
                 return {
                     type: 1,
                     renderResumeDataCache
@@ -107,33 +144,31 @@ function parsePostponedState(state, interpolatedParams, maxPostponedStateSizeByt
                 var _postponedString_match;
                 const match = (_postponedString_match = postponedString.match(/^([0-9]*)/)) == null ? void 0 : _postponedString_match[1];
                 if (!match) {
-                    throw Object.defineProperty(new Error(`Invariant: invalid postponed state ${JSON.stringify(postponedString)}`), "__NEXT_ERROR_CODE", {
-                        value: "E314",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Invariant: invalid postponed state ${JSON.stringify(postponedString)}`);
                 }
-                // This is the length of the replacements entries.
+                // This is the length of the serialized fallback params.
                 const length = parseInt(match);
-                const replacements = JSON.parse(postponedString.slice(match.length, // We then go to the end of the string.
+                const fallbackParamNames = JSON.parse(postponedString.slice(match.length, // We then go to the end of the string.
                 match.length + length));
-                let postponed = postponedString.slice(match.length + length);
-                for (const [segmentKey, [searchValue, dynamicParamType]] of replacements){
-                    const { treeSegment: [, // This is the same value that'll be used in the postponed state
-                    // as it's part of the tree data. That's why we use it as the
-                    // replacement value.
-                    value] } = (0, _getdynamicparam.getDynamicParam)(interpolatedParams, segmentKey, dynamicParamType, null, null // staticSiblings not needed for postponed state
-                    );
-                    postponed = postponed.replaceAll(searchValue, value);
+                const stagedFallbackParams = fallbackParamNames.length > 0 ? new Set(fallbackParamNames) : null;
+                const postponed = postponedString.slice(match.length + length);
+                if (postponed === 'null') {
+                    return {
+                        type: 1,
+                        stagedFallbackParams,
+                        renderResumeDataCache
+                    };
                 }
                 return {
                     type: 2,
+                    stagedFallbackParams,
                     data: JSON.parse(postponed),
                     renderResumeDataCache
                 };
             }
             return {
                 type: 2,
+                stagedFallbackParams: null,
                 data: JSON.parse(postponedString),
                 renderResumeDataCache
             };
@@ -158,8 +193,9 @@ function parsePostponedState(state, interpolatedParams, maxPostponedStateSizeByt
  * sensitive) serialized contents. Every field is a size, a structural flag, or
  * an error code, never the state bytes themselves.
  *
- * The serialized layout is `<N>:<postponedString><base64-deflate cache>`, so
- * these fields distinguish the failure shapes:
+ * The serialized layout is `<N>:<postponedString><cache>`. The cache is a
+ * base64-deflate string by default and raw JSON when RDC compression is
+ * disabled, so these fields distinguish the failure shapes:
  * - `postponedStringComplete: false`: the declared length `N` exceeds what
  * actually arrived, i.e. the postponed string itself was truncated.
  * - `errorCode: 'Z_BUF_ERROR'` with an empty or short tail: the
@@ -209,16 +245,16 @@ function isEmptyHTMLPrelude(state) {
         if (postponedString === 'null') {
             return false;
         }
-        // An optional `<n><replacements>` prefix carries fallback route param
-        // replacements; skip it to reach the `[preludeState, postponed]` data.
+        // An optional `<n><fallbackParams>` prefix records the unknown params;
+        // skip it to reach the `[preludeState, postponed]` data.
         if (/^[0-9]/.test(postponedString)) {
             var _postponedString_match;
-            const replacementsLengthMatch = (_postponedString_match = postponedString.match(/^([0-9]*)/)) == null ? void 0 : _postponedString_match[1];
-            if (!replacementsLengthMatch) {
+            const fallbackParamsLengthMatch = (_postponedString_match = postponedString.match(/^([0-9]*)/)) == null ? void 0 : _postponedString_match[1];
+            if (!fallbackParamsLengthMatch) {
                 return false;
             }
-            const replacementsLength = parseInt(replacementsLengthMatch);
-            postponedString = postponedString.slice(replacementsLengthMatch.length + replacementsLength);
+            const fallbackParamsLength = parseInt(fallbackParamsLengthMatch);
+            postponedString = postponedString.slice(fallbackParamsLengthMatch.length + fallbackParamsLength);
         }
         const data = JSON.parse(postponedString);
         return Array.isArray(data) && data[0] === 0;

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

@@ -45,13 +45,9 @@ function printDebugThrownValueForProspectiveRender(thrownValue, route, phase) {
             const originalErrorStack = thrownValue.stack;
             const stackStart = originalErrorStack.indexOf('\n');
             if (stackStart > -1) {
-                const error = Object.defineProperty(new Error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled.
+                const error = new Error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled.
           
-Original Error: ${message}`), "__NEXT_ERROR_CODE", {
-                    value: "E949",
-                    enumerable: false,
-                    configurable: true
-                });
+Original Error: ${message}`);
                 error.stack = 'Error: ' + error.message + originalErrorStack.slice(stackStart);
                 console.error(error);
                 return;

package/.next/standalone/node_modules/next/dist/server/app-render/render-in-browser.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRenderInBrowserAbortSignal", {
+    enumerable: true,
+    get: function() {
+        return createRenderInBrowserAbortSignal;
+    }
+});
+const _reactdom = require("react-dom");
+const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
+const _reactbrowserbailout = require("../../shared/lib/lazy-dynamic/react-browser-bailout");
+const RENDER_IN_BROWSER_BAILOUT_REASON = 'Render in Browser';
+const getRenderInBrowserBailoutReason = _reactbrowserbailout.createReactBrowserBailoutReason.bind(null, RENDER_IN_BROWSER_BAILOUT_REASON);
+function createRenderInBrowserAbortSignal(reactBrowserBailout) {
+    const controller = new AbortController();
+    if (reactBrowserBailout) {
+        // @ts-expect-error TODO: Update @types/react-dom to include the reason argument.
+        controller.abort((0, _reactdom.browser)(getRenderInBrowserBailoutReason));
+    } else {
+        controller.abort(new _bailouttocsr.BailoutToCSRError(RENDER_IN_BROWSER_BAILOUT_REASON));
+    }
+    return controller.signal;
+}
+
+//# sourceMappingURL=render-in-browser.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/required-scripts.js

@@ -25,11 +25,7 @@ function getRequiredScripts(buildManifest, assetPrefix, crossOrigin, SRIManifest
     };
     const files = (((_buildManifest_rootMainFilesTree = buildManifest.rootMainFilesTree) == null ? void 0 : _buildManifest_rootMainFilesTree[pagePath]) || buildManifest.rootMainFiles).map(_encodeuripath.encodeURIPath);
     if (files.length === 0) {
-        throw Object.defineProperty(new Error('Invariant: missing bootstrap script. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
-            value: "E459",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant: missing bootstrap script. This is a bug in Next.js');
     }
     if (SRIManifest) {
         bootstrapScript.src = `${assetPrefix}/_next/` + files[0] + qs;

package/.next/standalone/node_modules/next/dist/server/app-render/rsc/taint.js

@@ -67,11 +67,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 function notImplemented() {
-    throw Object.defineProperty(new Error('Taint can only be used with the taint flag.'), "__NEXT_ERROR_CODE", {
-        value: "E354",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('Taint can only be used with the taint flag.');
 }
 const taintObjectReference = process.env.__NEXT_EXPERIMENTAL_REACT ? _react.experimental_taintObjectReference : notImplemented;
 const taintUniqueValue = process.env.__NEXT_EXPERIMENTAL_REACT ? _react.experimental_taintUniqueValue : notImplemented;