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

package/.next/standalone/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/.next/standalone/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`

package/.next/standalone/node_modules/next/dist/server/app-render/stream-ops.node.js

@@ -132,10 +132,11 @@ const _constants = require("../../shared/lib/errors/constants");
 const _htmlescape = require("../../shared/lib/htmlescape");
 const _useflightresponse = require("./use-flight-response");
 const _apprenderprerenderutils = require("./app-render-prerender-utils");
-const _detachedpromise = require("../../lib/detached-promise");
+const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 const _tracer = require("../lib/trace/tracer");
 const _constants1 = require("../lib/trace/constants");
 const _scheduler = require("../../lib/scheduler");
+const _nextrequest = require("../web/spec-extension/adapters/next-request");
 const _streamopsweb = require("./stream-ops.web");
 function nodeReadableToWebReadableStream(stream) {
     if (stream instanceof ReadableStream) {
@@ -473,11 +474,7 @@ function createRootLayoutValidatorTransform() {
 }
 function renderToNodeFlightStream(ComponentMod, payload, clientModules, opts) {
     if (!ComponentMod.renderToPipeableStream) {
-        throw Object.defineProperty(new Error('renderToPipeableStream is not implemented'), "__NEXT_ERROR_CODE", {
-            value: "E1153",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('renderToPipeableStream is not implemented');
     }
     // `renderToPipeableStream` has no `signal` option (unlike the Web
     // `renderToReadableStream`), so pull `signal` out of the options and abort
@@ -487,6 +484,15 @@ function renderToNodeFlightStream(ComponentMod, payload, clientModules, opts) {
     const { signal, ...renderOptions } = opts ?? {};
     const pt = new _nodestream.PassThrough();
     const pipeable = ComponentMod.renderToPipeableStream(payload, clientModules, renderOptions);
+    // If the destination is destroyed before the render ended, React aborts with a
+    // generic "The destination stream closed early." error that `onError` can't
+    // tell apart from a real render error. Abort first with the reason we already
+    // know; the listener is registered before piping so it runs before React's.
+    pt.once('close', ()=>{
+        if (!pt.writableEnded) {
+            pipeable.abort(new _nextrequest.ResponseAborted());
+        }
+    });
     pipeable.pipe(pt);
     if (signal) {
         if (signal.aborted) {
@@ -503,8 +509,8 @@ function renderToNodeFlightStream(ComponentMod, payload, clientModules, opts) {
 }
 async function renderToNodeFizzStream(element, streamOptions, options) {
     const pt = new _nodestream.PassThrough();
-    const shellReady = new _detachedpromise.DetachedPromise();
-    const allReady = new _detachedpromise.DetachedPromise();
+    const shellReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
+    const allReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
     const deferPipe = (options == null ? void 0 : options.waitForAllReady) === true;
     const pipeable = (0, _tracer.getTracer)().trace(_constants1.AppRenderSpan.renderToReadableStream, ()=>(0, _server.renderToPipeableStream)(element, {
             ...streamOptions,
@@ -543,8 +549,8 @@ async function renderToNodeFizzStream(element, streamOptions, options) {
 async function resumeToFizzStream(element, postponedState, streamOptions, runInContext) {
     const run = runInContext ?? ((fn)=>fn());
     const pt = new _nodestream.PassThrough();
-    const shellReady = new _detachedpromise.DetachedPromise();
-    const allReady = new _detachedpromise.DetachedPromise();
+    const shellReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
+    const allReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
     const pipeable = await run(()=>(0, _server.resumeToPipeableStream)(element, postponedState, {
             ...streamOptions,
             onShellReady () {
@@ -579,10 +585,10 @@ async function resumeAndAbort(element, postponed, opts) {
     pipeable.abort(opts == null ? void 0 : (_opts_signal = opts.signal) == null ? void 0 : _opts_signal.reason);
     return pt;
 }
-async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, allReady, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
+async function continueFizzStream(renderStream, { suffix, inlinedDataStream, waitForAllReady, allReady, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
     // Suffix itself might contain close tags at the end, so we need to split it.
     const suffixUnclosed = suffix ? suffix.split(_nodewebstreamshelper.CLOSE_TAG, 1)[0] : null;
-    if (isStaticGeneration) {
+    if (waitForAllReady) {
         if (allReady) {
             await allReady;
         }

package/.next/standalone/node_modules/next/dist/server/app-render/stream-ops.web.js

@@ -152,11 +152,7 @@ async function continueDynamicHTMLResumeWeb(renderStream, opts) {
     });
 }
 function continueDynamicHTMLResumeNode(_renderStream, _opts) {
-    throw Object.defineProperty(new Error('not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1154",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('not implemented');
 }
 async function streamToBuffer(stream) {
     return (0, _nodewebstreamshelper.streamToBuffer)(stream);
@@ -174,11 +170,7 @@ function createWebInlinedDataStream(source, nonce, formState) {
     return (0, _useflightresponse.createInlinedDataReadableStream)(source, nonce, formState);
 }
 function createNodeInlinedDataStream(_source, _nonce, _formState) {
-    throw Object.defineProperty(new Error('not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1154",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('not implemented');
 }
 function createPendingStream() {
     return new ReadableStream();
@@ -194,11 +186,7 @@ async function resumeAndAbort(element, postponed, opts) {
     return (0, _server.resume)(element, postponed, opts);
 }
 function renderToNodeFlightStream(_ComponentMod, _payload, _clientModules, _opts) {
-    throw Object.defineProperty(new Error('not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1154",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('not implemented');
 }
 function renderToWebFlightStream(ComponentMod, payload, clientModules, opts) {
     return ComponentMod.renderToReadableStream(payload, clientModules, opts);
@@ -221,11 +209,7 @@ async function renderToWebFizzStream(element, streamOptions, _options) {
     };
 }
 async function renderToNodeFizzStream(_element, _streamOptions, _options) {
-    throw Object.defineProperty(new Error('Not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1155",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('Not implemented');
 }
 async function resumeToFizzStream(element, postponedState, streamOptions) {
     const stream = await (0, _server.resume)(element, postponedState, streamOptions);

package/.next/standalone/node_modules/next/dist/server/app-render/sync-io-messages.js

@@ -43,11 +43,7 @@ function elapsedTimeBullet(type) {
     return type === 'time' ? `\n  - [measure] If the value is for telemetry, use a timing API such as \`performance.now()\`` : '';
 }
 function createSyncIOErrorImpl(route, expression, type, docsUrl) {
-    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered the unstable value ${expression} while prerendering.\n\n` + `This value can change between renders, so it must be either prerendered or computed later.\n\n` + `Ways to fix this:\n` + `  - [dynamic] Render at request time by adding a dynamic data access (e.g. \`await connection()\`) before this call\n` + `  - [cache] Prerender and cache the value with \`"use cache"\`\n` + `  - [client] Render the value on the client with \`"use client"\`` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`), "__NEXT_ERROR_CODE", {
-        value: "E1432",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`Route "${route}": Next.js encountered the unstable value ${expression} while prerendering.\n\n` + `This value can change between renders, so it must be either prerendered or computed later.\n\n` + `Ways to fix this:\n` + `  - [dynamic] Render at request time by adding a dynamic data access (e.g. \`await connection()\`) before this call\n` + `  - [cache] Prerender and cache the value with \`"use cache"\`\n` + `  - [client] Render the value on the client with \`"use client"\`` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`);
 }
 function createSyncIOError(route, expression, type) {
     return createSyncIOErrorImpl(route, expression, type, SYNC_IO_DOCS[type]);
@@ -57,11 +53,7 @@ function createSyncIORuntimeError(route, expression, type) {
 }
 function createSyncIOClientError(route, expression, type) {
     const docsUrl = SYNC_IO_CLIENT_DOCS[type];
-    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered the unstable value ${expression} in a Client Component.\n\n` + `This value would be evaluated during the prerender, instead of recomputed on each visit.\n\n` + `Ways to fix this:\n` + `  - [stream] Wrap the Client Component in \`<Suspense fallback={...}>\`\n` + `  - [defer] Move the read into a \`useEffect\` or event handler` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`), "__NEXT_ERROR_CODE", {
-        value: "E1434",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`Route "${route}": Next.js encountered the unstable value ${expression} in a Client Component.\n\n` + `This value would be evaluated during the prerender, instead of recomputed on each visit.\n\n` + `Ways to fix this:\n` + `  - [stream] Wrap the Client Component in \`<Suspense fallback={...}>\`\n` + `  - [defer] Move the read into a \`useEffect\` or event handler` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`);
 }
 
 //# sourceMappingURL=sync-io-messages.js.map

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

@@ -59,7 +59,8 @@ const flightRouterStateSchema = _superstruct.default.tuple([
         _superstruct.default.literal('inside-shared-layout'),
         _superstruct.default.literal('metadata-only')
     ]))),
-    _superstruct.default.optional(_superstruct.default.number())
+    _superstruct.default.optional(_superstruct.default.nullable(_superstruct.default.number())),
+    _superstruct.default.optional(_superstruct.default.string())
 ]);
 
 //# sourceMappingURL=types.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/use-flight-response.js

@@ -42,11 +42,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
     if (flightStream instanceof ReadableStream) {
         // The types of flightStream and debugStream should match.
         if (debugStream && !(debugStream instanceof ReadableStream)) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Expected debug stream to be a ReadableStream'), "__NEXT_ERROR_CODE", {
-                value: "E939",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Expected debug stream to be a ReadableStream');
         }
         // react-server-dom-webpack/client.edge must not be hoisted for require cache clearing to work correctly
         const { createFromReadableStream } = // eslint-disable-next-line import/no-extraneous-dependencies
@@ -66,11 +62,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
         });
     } else {
         if (process.env.NEXT_RUNTIME === 'edge') {
-            throw Object.defineProperty(new _invarianterror.InvariantError('getFlightStream should always receive a ReadableStream when using the edge runtime'), "__NEXT_ERROR_CODE", {
-                value: "E943",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('getFlightStream should always receive a ReadableStream when using the edge runtime');
         } else {
             const { Readable } = require('node:stream');
             // Convert debug stream to Readable if it's a ReadableStream.
@@ -104,11 +96,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
     if (process.env.NEXT_RUNTIME !== 'edge') {
         const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
         if (!workUnitStore) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.'), "__NEXT_ERROR_CODE", {
-                value: "E696",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.');
         }
         switch(workUnitStore.type){
             case 'prerender-client':
@@ -122,13 +110,12 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
                 return responseOnNextTick;
             case 'prerender':
             case 'prerender-runtime':
-            case 'prerender-ppr':
             case 'prerender-legacy':
             case 'request':
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;

package/.next/standalone/node_modules/next/dist/server/app-render/vary-params.js

@@ -61,23 +61,24 @@ _export(exports, {
     }
 });
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
+const _varyparamsdecoding = require("../../shared/lib/segment-cache/vary-params-decoding");
 class VaryParamsAccumulator {
     /**
    * Records that a param was accessed. Yields the name into the stream the
    * first time it's seen; subsequent accesses of the same name are no-ops.
-   */ add(paramName) {
-        if (this._done || this._seen.has(paramName)) {
+   */ add(id) {
+        if (this._done || this._seen.has(id)) {
             return;
         }
-        this._seen.add(paramName);
+        this._seen.add(id);
         if (this._resolve !== null) {
             this._resolve({
-                value: paramName,
+                value: id,
                 done: false
             });
             this._resolve = null;
         } else {
-            this._buffer.push(paramName);
+            this._buffer.push(id);
         }
     }
     /** Ends the iteration. Best-effort: if skipped (e.g. on a sync-I/O abort),
@@ -168,8 +169,8 @@ function getRootParamsVaryParamsAccumulator() {
     }
     return ((_getVaryParamsAccumulator = (0, _workunitasyncstorageexternal.getVaryParamsAccumulator)(workUnitStore)) == null ? void 0 : _getVaryParamsAccumulator.rootParams) ?? null;
 }
-function accumulateVaryParam(accumulator, paramName) {
-    accumulator.add(paramName);
+function accumulateVaryParam(accumulator, id) {
+    accumulator.add(id);
 }
 function accumulateRootVaryParam(paramName) {
     const rootParamsAccumulator = getRootParamsVaryParamsAccumulator();
@@ -229,23 +230,23 @@ function createVaryingSearchParams(accumulator, originalSearchParamsObject) {
     // checks, or enumeration — must register as varying. A Proxy is required
     // (rather than per-property getters) so that enumeration of an empty
     // searchParams object still triggers a vary. All accesses bucket into the
-    // single sentinel '?'; the segment is keyed by the whole query string.
+    // single search params id; the segment is keyed by the whole query string.
     // TODO: Split into per-param tracking if the cache key evolves.
     return new Proxy(originalSearchParamsObject, {
         get (target, prop, receiver) {
             if (typeof prop === 'string') {
-                accumulateVaryParam(accumulator, '?');
+                accumulateVaryParam(accumulator, _varyparamsdecoding.SEARCH_PARAMS_VARY_ID);
             }
             return Reflect.get(target, prop, receiver);
         },
         has (target, prop) {
             if (typeof prop === 'string') {
-                accumulateVaryParam(accumulator, '?');
+                accumulateVaryParam(accumulator, _varyparamsdecoding.SEARCH_PARAMS_VARY_ID);
             }
             return Reflect.has(target, prop);
         },
         ownKeys (target) {
-            accumulateVaryParam(accumulator, '?');
+            accumulateVaryParam(accumulator, _varyparamsdecoding.SEARCH_PARAMS_VARY_ID);
             return Reflect.ownKeys(target);
         }
     });