@sifxprime/krouter 0.5.166 → 0.5.167

package/app/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/app/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/app/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/app/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/app/node_modules/next/dist/server/app-render/segment-config/ensure-static.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    EnsureStaticLevel: null,
+    resolveEnsureStaticConfig: null,
+    resolveEnsureStaticLevel: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    EnsureStaticLevel: function() {
+        return EnsureStaticLevel;
+    },
+    resolveEnsureStaticConfig: function() {
+        return resolveEnsureStaticConfig;
+    },
+    resolveEnsureStaticLevel: function() {
+        return resolveEnsureStaticLevel;
+    }
+});
+const _parseloadertree = require("../../../shared/lib/router/utils/parse-loader-tree");
+const _appdirmodule = require("../../lib/app-dir-module");
+var EnsureStaticLevel = /*#__PURE__*/ function(EnsureStaticLevel) {
+    /** The route follows standard Partial Prefetching semantics. */ EnsureStaticLevel[EnsureStaticLevel["None"] = 0] = "None";
+    /** The route requires that app shells must be statically prerendered. */ EnsureStaticLevel[EnsureStaticLevel["Shell"] = 1] = "Shell";
+    /** The route requires that app shells and prefetches must be statically prerendered. */ EnsureStaticLevel[EnsureStaticLevel["Prefetch"] = 2] = "Prefetch";
+    /** The route requires that app shells, prefetches, and the whole page must be statically prerendered. */ EnsureStaticLevel[EnsureStaticLevel["Navigation"] = 3] = "Navigation";
+    return EnsureStaticLevel;
+}({});
+function getEnsureStaticLevel(ensureStatic) {
+    switch(ensureStatic){
+        case 'auto':
+        case false:
+            {
+                return 0;
+            }
+        case 'shell':
+            {
+                return 1;
+            }
+        case 'prefetch':
+            {
+                return 2;
+            }
+        case 'navigation':
+            {
+                return 3;
+            }
+    }
+}
+async function resolveEnsureStaticLevel(tree, partialPrefetching) {
+    return getEnsureStaticLevel(await resolveEnsureStaticConfig(tree, partialPrefetching));
+}
+async function resolveEnsureStaticConfig(tree, partialPrefetching) {
+    let { config, filePath } = await resolveEnsureStaticConfigImpl(tree);
+    if (!partialPrefetching) {
+        // If Partial Prefetching is not enabled for this route, we only support
+        // a subset of `ensureStatic` values.
+        // (We error in `getAppPageStaticInfo` if `ensureStatic` is used without enabling
+        // Cache Components, so we don't have to assert that here)
+        switch(config){
+            case 'auto':
+                {
+                    // Default to the equivalent of Cache Components prefetching behavior.
+                    config = 'prefetch';
+                    break;
+                }
+            case false:
+            case 'shell':
+                {
+                    // Not meaningful in Cache Components without Partial Prefetching
+                    const originalConfig = config;
+                    config = 'prefetch';
+                    console.warn(`${formatEnsureStaticExport(originalConfig)} has no effect unless the route is using Partial Prefetching.` + `\n  (from: ${filePath})`);
+                    break;
+                }
+            case 'prefetch':
+                break;
+            case 'navigation':
+                break;
+            default:
+                config;
+        }
+    }
+    if (config === false) {
+        // `false` and "auto" are equivalent once resolved.
+        return 'auto';
+    } else {
+        return config;
+    }
+}
+async function resolveEnsureStaticConfigImpl(tree) {
+    const { mod: layoutOrPageMod, filePath } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    const config = getEnsureStaticConfigForModule(layoutOrPageMod);
+    const parentResult = {
+        config,
+        filePath: filePath ?? null
+    };
+    // Walk the slots if any and validate that they don't have incompatible configs
+    // with each other. If compatible, pick the most constrained value from the slots.
+    let slotsResult = null;
+    let slotResultKey = null;
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const childResult = await resolveEnsureStaticConfigImpl(parallelRoute);
+        if (!slotsResult) {
+            slotsResult = childResult;
+            slotResultKey = parallelRouteKey;
+        } else {
+            // Check if the child is compatible with the current result for the slots.
+            switch(compareEnsureStatic(childResult.config, slotsResult.config)){
+                case 2:
+                    {
+                        // 'auto' is compatible with anything, but if the current result is 'auto' and the new one isn't,
+                        // we want to use the more specific result.
+                        if (slotsResult.config === 'auto' && childResult.config !== 'auto') {
+                            slotsResult = childResult;
+                            slotResultKey = parallelRouteKey;
+                        }
+                        break;
+                    }
+                case 4:
+                case 1:
+                case 3:
+                    {
+                        throw new Error(`Parallel slots cannot have incompatible \`ensureStatic\`.` + `\n  ${formatParallelSlot(slotResultKey)}: ` + `\n    ${formatEnsureStaticExport(slotsResult.config)}` + `\n    (from: ${slotsResult.filePath})` + `\n` + `\n  ${formatParallelSlot(parallelRouteKey)}: ` + `\n    ${formatEnsureStaticExport(childResult.config)}` + `\n    (from: ${childResult.filePath})` + `\n` + `\n Possible fixes:` + `\n - Remove one of the \`ensureStatic\` exports` + `\n - Change one of the  \`ensureStatic\` exports to match the other`);
+                    }
+            }
+        }
+    }
+    // Child segments can override the config from the parent with a more constrained value,
+    // but they cannot have a less constrained value.
+    if (!slotsResult) {
+        return parentResult;
+    } else {
+        const comparison = compareEnsureStatic(slotsResult.config, parentResult.config);
+        switch(comparison){
+            case 2:
+                {
+                    // 'auto' is compatible with anything, but if the parent result is 'auto' and the slots one isn't,
+                    // we want to use the more constrained result.
+                    if (parentResult.config === 'auto' && slotsResult.config !== 'auto') {
+                        return slotsResult;
+                    } else {
+                        return parentResult;
+                    }
+                }
+            case 3:
+                {
+                    return slotsResult;
+                }
+            case 1:
+            case 4:
+                {
+                    throw new Error((comparison === 1 ? `A child segment cannot override a parent segment with a less-constrained \`ensureStatic\`.` : `A child segment cannot override a parent segment with an incompatible \`ensureStatic\`.`) + `\n  Parent has: ` + `\n    ${formatEnsureStaticExport(parentResult.config)}` + `\n    (from: ${parentResult.filePath})` + `\n  Child has: ` + `\n    ${formatEnsureStaticExport(slotsResult.config)}` + `\n    (from: ${slotsResult.filePath})` + `\n` + `\n Possible fixes:` + `\n - Remove one of the \`ensureStatic\` exports` + `\n - Change one of the  \`ensureStatic\` exports to match the other`);
+                }
+        }
+    }
+}
+function formatParallelSlot(slot) {
+    return slot === 'children' ? slot : `@${slot}`;
+}
+function formatEnsureStaticExport(config) {
+    return `export const ensureStatic = ${JSON.stringify(config)}`;
+}
+var Comparison = /*#__PURE__*/ function(Comparison) {
+    Comparison[Comparison["LessConstrained"] = 1] = "LessConstrained";
+    Comparison[Comparison["Compatible"] = 2] = "Compatible";
+    Comparison[Comparison["MoreConstrained"] = 3] = "MoreConstrained";
+    Comparison[Comparison["Incompatible"] = 4] = "Incompatible";
+    return Comparison;
+}(Comparison || {});
+const ENSURE_STATIC_ORDER = [
+    'shell',
+    'prefetch',
+    'navigation'
+];
+function compareEnsureStatic(left, right) {
+    // 'auto' is compatible with everything.
+    if (left === 'auto' || right === 'auto') {
+        return 2;
+    }
+    // `false` is compatible with false.
+    if (left === false && right === false) {
+        return 2;
+    }
+    // If only one of the values is `false` (we know it's not both), it's incompatible.
+    if (left === false || right === false) {
+        return 4;
+    }
+    const leftSort = ENSURE_STATIC_ORDER.indexOf(left);
+    const rightSort = ENSURE_STATIC_ORDER.indexOf(right);
+    return leftSort < rightSort ? 1 : leftSort === rightSort ? 2 : 3;
+}
+function getEnsureStaticConfigForModule(mod) {
+    return (mod ? mod.ensureStatic : undefined) ?? 'auto';
+}
+
+//# sourceMappingURL=ensure-static.js.map

package/app/node_modules/next/dist/server/app-render/staged-rendering.js

@@ -41,21 +41,30 @@ const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers")
 var RenderStage = /*#__PURE__*/ function(RenderStage) {
     RenderStage[RenderStage["Before"] = 1] = "Before";
     //
-    RenderStage[RenderStage["ShellStatic"] = 11] = "ShellStatic";
-    RenderStage[RenderStage["Static"] = 13] = "Static";
+    RenderStage[RenderStage["ShellStatic"] = 10] = "ShellStatic";
+    /** Discrimination-only stage: `prefetch()` in validation renders (static) */ RenderStage[RenderStage["PrefetchStatic_prefetchApi"] = 11] = "PrefetchStatic_prefetchApi";
+    RenderStage[RenderStage["PrefetchStatic"] = 12] = "PrefetchStatic";
+    RenderStage[RenderStage["NavigationStatic"] = 13] = "NavigationStatic";
+    RenderStage[RenderStage["Static"] = 14] = "Static";
     //
-    RenderStage[RenderStage["ShellRuntime"] = 21] = "ShellRuntime";
-    RenderStage[RenderStage["Runtime"] = 23] = "Runtime";
+    RenderStage[RenderStage["ShellRuntime"] = 20] = "ShellRuntime";
+    /** Discrimination-only stage: `prefetch()` in validation renders (runtime) */ RenderStage[RenderStage["PrefetchRuntime_prefetchApi"] = 21] = "PrefetchRuntime_prefetchApi";
+    RenderStage[RenderStage["PrefetchRuntime"] = 22] = "PrefetchRuntime";
+    RenderStage[RenderStage["NavigationRuntime"] = 23] = "NavigationRuntime";
     //
     RenderStage[RenderStage["Dynamic"] = 30] = "Dynamic";
-    //
     RenderStage[RenderStage["Abandoned"] = 40] = "Abandoned";
     return RenderStage;
 }({});
 const RENDER_STAGE_ADVANCE_ORDER = [
+    10,
     11,
+    12,
     13,
+    14,
+    20,
     21,
+    22,
     23,
     30
 ];
@@ -75,15 +84,7 @@ class StagedRenderingController {
     constructor({ abortSignal, abandonController, syncIO, finalStage }){
         this.currentStage = 1;
         this.syncInterruptReason = null;
-        this.triggers = {
-            [11]: createStageTrigger(),
-            [13]: createStageTrigger(),
-            //
-            [21]: createStageTrigger(),
-            [23]: createStageTrigger(),
-            //
-            [30]: createStageTrigger()
-        };
+        this.triggers = createAdvanceableStageTriggers();
         this.abortSignal = abortSignal;
         this.abandonController = abandonController;
         this.syncIOMode = syncIO;
@@ -108,42 +109,34 @@ class StagedRenderingController {
             });
         }
     }
-    onStage(stage, callback) {
+    /**
+   * Schedules a callback that will execute synchronously when the controller is advanced
+   * to `stage` or past it, before any promises for that stage are resolved.
+   * If the controller is already past `stage`, the callback is executed immediately.
+   * */ onStage(stage, callback) {
         addSyncTriggerListener(this.triggers[stage], callback);
     }
     shouldTrackSyncInterrupt() {
-        if (this.syncIOMode === 1) {
-            return false;
-        }
-        switch(this.currentStage){
+        const { syncIOMode, currentStage } = this;
+        switch(syncIOMode){
             case 1:
-                // If we haven't started the render yet, it can't be interrupted.
-                return false;
-            case 11:
-            case 13:
-                return true;
-            case 21:
-            case 23:
                 {
-                    switch(this.syncIOMode){
-                        case 2:
-                            {
-                                // Before `partialPrefetching`: Sync IO only errors in static stages.
-                                return false;
-                            }
-                        case 3:
-                            {
-                                return true;
-                            }
-                    }
-                // NOT a fallthrough, but eslint doesn't understand that
+                    return false;
+                }
+            case 2:
+                {
+                    // Legacy: track Sync IO only in static stages.
+                    // Do not track it before the render, or in runtime/dynamic stages.
+                    return currentStage > 1 && currentStage <= 14;
+                }
+            case 3:
+                {
+                    // Track sync IO in all cacheable stages.
+                    // This means all stages except:
+                    // - before the render
+                    // - in the dynamic stage
+                    return currentStage > 1 && currentStage < 30;
                 }
-            case 30:
-            case 40:
-                return false;
-            default:
-                this.currentStage;
-                return false;
         }
     }
     /** Note: only call this if `shouldTrackSyncInterrupt()` returned true */ syncInterruptCurrentStageWithReason(reason) {
@@ -191,11 +184,7 @@ class StagedRenderingController {
         // unblocking the dynamic stage would likely lead to wasted (uncached) IO.
         const { currentStage } = this;
         if (currentStage === 1) {
-            throw Object.defineProperty(new _invarianterror.InvariantError("A render that hasn't started yet cannot be abandoned"), "__NEXT_ERROR_CODE", {
-                value: "E1300",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError("A render that hasn't started yet cannot be abandoned");
         }
         if (currentStage === 30 || currentStage === 40) {
             // We shouldn't ever trigger an abandon in these. Defensive noop.
@@ -211,11 +200,7 @@ class StagedRenderingController {
     }
     advanceStage(targetStage) {
         if (this.finalStage !== null && targetStage > this.finalStage) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Attempted to advance to stage ${RenderStage[targetStage]} but the render is limited to ${RenderStage[this.finalStage]}`), "__NEXT_ERROR_CODE", {
-                value: "E1302",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Attempted to advance to stage ${RenderStage[targetStage]} but the render is limited to ${RenderStage[this.finalStage]}`);
         }
         const { currentStage } = this;
         if (currentStage === 30 || currentStage === 40) {
@@ -255,6 +240,13 @@ class StagedRenderingController {
         return promise;
     }
 }
+function createAdvanceableStageTriggers() {
+    const triggers = {};
+    for (const stage of RENDER_STAGE_ADVANCE_ORDER){
+        triggers[stage] = createStageTrigger();
+    }
+    return triggers;
+}
 function ignoreReject() {}
 // TODO(restart-on-cache-miss): the layering of `delayUntilStage`,
 // `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise`