@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/next.js

@@ -33,7 +33,6 @@ const _tracer = require("./lib/trace/tracer");
 const _constants2 = require("./lib/trace/constants");
 const _formaturl = require("../shared/lib/router/utils/format-url");
 const _asynccallbackset = require("./lib/async-callback-set");
-const _routerservercontext = require("./lib/router-utils/router-server-context");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -153,6 +152,12 @@ class NextServer {
             this.preparedAssetPrefix = assetPrefix;
         }
     }
+    getAssetPrefix() {
+        if (!this.server) {
+            throw new Error('prepare() must be called before getting assetPrefix');
+        }
+        return this.server.getAssetPrefix();
+    }
     logError(...args) {
         if (this.server) {
             this.server.logError(...args);
@@ -225,34 +230,40 @@ class NextServer {
         if (!this.options.dev) {
             try {
                 const serializedConfig = require(/* turbopackIgnore: true */ _nodepath.default.join(/* turbopackIgnore: true */ dir, config.distDir, _constants1.SERVER_FILES_MANIFEST + '.json')).config;
-                config.experimental.isExperimentalCompile = serializedConfig.experimental.isExperimentalCompile;
+                return {
+                    config,
+                    compileMode: {
+                        isExperimentalCompile: serializedConfig.experimental.isExperimentalCompile
+                    }
+                };
             } catch (_) {
             // if distDir is customized we don't know until we
             // load the config so fallback to loading the config
             // from next.config.js
             }
         }
-        return config;
+        return {
+            config,
+            compileMode: undefined
+        };
     }
     async getServer() {
         if (!this.serverPromise) {
-            this.serverPromise = this[SYMBOL_LOAD_CONFIG]().then(async (conf)=>{
+            this.serverPromise = this[SYMBOL_LOAD_CONFIG]().then(async (result)=>{
+                const { config: conf, compileMode } = result;
                 if (!this.options.dev) {
                     if (conf.output === 'standalone') {
                         if (!process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
                             _log.warn(`"next start" does not work with "output: standalone" configuration. Use "node .next/standalone/server.js" instead.`);
                         }
                     } else if (conf.output === 'export') {
-                        throw Object.defineProperty(new Error(`"next start" does not work with "output: export" configuration. Use "npx serve@latest out" instead.`), "__NEXT_ERROR_CODE", {
-                            value: "E375",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`"next start" does not work with "output: export" configuration. Use "npx serve@latest out" instead.`);
                     }
                 }
                 this.server = await this.createServer({
                     ...this.options,
-                    conf
+                    conf,
+                    compileMode
                 });
                 if (this.preparedAssetPrefix) {
                     this.server.setAssetPrefix(this.preparedAssetPrefix);
@@ -282,11 +293,7 @@ class NextServer {
     }
     getInit() {
         if (!this.init) {
-            throw Object.defineProperty(new Error('prepare() must be called before performing this operation'), "__NEXT_ERROR_CODE", {
-                value: "E355",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('prepare() must be called before performing this operation');
         }
         return this.init;
     }
@@ -365,15 +372,8 @@ class NextServer {
         return;
     }
     setAssetPrefix(assetPrefix) {
-        var _routerServerGlobal_RouterServerContextSymbol_relativeProjectDir, _routerServerGlobal_RouterServerContextSymbol;
         warnDeprecatedCustomServerMethod('setAssetPrefix');
         this.server.setAssetPrefix(assetPrefix);
-        // update the router-server nextConfig instance as
-        // this is the source of truth for "handler" in serverful
-        const relativeProjectDir = _nodepath.default.relative(process.cwd(), this.options.dir || '');
-        if ((_routerServerGlobal_RouterServerContextSymbol = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) == null ? void 0 : (_routerServerGlobal_RouterServerContextSymbol_relativeProjectDir = _routerServerGlobal_RouterServerContextSymbol[relativeProjectDir]) == null ? void 0 : _routerServerGlobal_RouterServerContextSymbol_relativeProjectDir.nextConfig) {
-            _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir].nextConfig.assetPrefix = assetPrefix;
-        }
     }
     getUpgradeHandler() {
         return this.server.getUpgradeHandler();
@@ -425,11 +425,7 @@ function createServer(options) {
         // server option, so don't fall back to the default Turbopack auto mode.
         const selectRspack = !!process.env.NEXT_RSPACK;
         if (selectTurbopack && selectWebpack && selectRspack) {
-            throw Object.defineProperty(new Error('Pass either `webpack` or `turbopack`, not both.'), "__NEXT_ERROR_CODE", {
-                value: "E851",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Pass either `webpack` or `turbopack`, not both.');
         }
         if (selectTurbopack) {
             process.env.TURBOPACK ??= '1';
@@ -438,11 +434,7 @@ function createServer(options) {
         }
     } else {
         if (options && (options.webpack || options.turbo || options.turbopack)) {
-            throw Object.defineProperty(new Error('Only custom servers can pass `webpack`, `turbo`, or `turbopack`.'), "__NEXT_ERROR_CODE", {
-                value: "E852",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Only custom servers can pass `webpack`, `turbo`, or `turbopack`.');
         }
     }
     // The package is used as a TypeScript plugin.
@@ -451,11 +443,7 @@ function createServer(options) {
         return pluginMod.createTSPlugin(options);
     }
     if (options == null) {
-        throw Object.defineProperty(new Error('The server has not been instantiated properly. https://nextjs.org/docs/messages/invalid-server-options'), "__NEXT_ERROR_CODE", {
-            value: "E75",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('The server has not been instantiated properly. https://nextjs.org/docs/messages/invalid-server-options');
     }
     if (!('isNextDevCommand' in options) && process.env.NODE_ENV && ![
         'production',

package/app/node_modules/next/dist/server/node-environment-extensions/console-dim.external.js

@@ -250,12 +250,11 @@ function patchConsoleMethod(methodName) {
                     }
                 // intentional fallthrough
                 case 'prerender-legacy':
-                case 'prerender-ppr':
                 case 'cache':
                 case 'unstable-cache':
                 case 'private-cache':
                 case 'request':
-                case 'generate-static-params':
+                case 'build-time-generator':
                 case undefined:
                     if ((consoleStore == null ? void 0 : consoleStore.dim) === true) {
                         return applyWithDimming.call(this, consoleStore, originalMethod, methodName, args);

package/app/node_modules/next/dist/server/node-environment-extensions/fast-set-immediate.external.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     DANGEROUSLY_runPendingImmediatesAfterCurrentTask: null,
+    ImmediateTracker: null,
     expectNoPendingImmediates: null,
+    runWithNativeImmediateTracking: null,
     unpatchedSetImmediate: null
 });
 function _export(target, all) {
@@ -17,9 +19,15 @@ _export(exports, {
     DANGEROUSLY_runPendingImmediatesAfterCurrentTask: function() {
         return DANGEROUSLY_runPendingImmediatesAfterCurrentTask;
     },
+    ImmediateTracker: function() {
+        return ImmediateTracker;
+    },
     expectNoPendingImmediates: function() {
         return expectNoPendingImmediates;
     },
+    runWithNativeImmediateTracking: function() {
+        return runWithNativeImmediateTracking;
+    },
     unpatchedSetImmediate: function() {
         return originalSetImmediate;
     }
@@ -67,11 +75,7 @@ function install() {
 }
 function DANGEROUSLY_runPendingImmediatesAfterCurrentTask() {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('DANGEROUSLY_runPendingImmediatesAfterCurrentTask cannot be called in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E960",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('DANGEROUSLY_runPendingImmediatesAfterCurrentTask cannot be called in the edge runtime');
     } else {
         const execution = startCapturingImmediates();
         try {
@@ -82,43 +86,114 @@ function DANGEROUSLY_runPendingImmediatesAfterCurrentTask() {
                 throw err;
             }
             // Otherwise, bail out here.
-            bail(execution, Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occurred while starting to capture immediates', {
+            bail(execution, new _invarianterror.InvariantError('An unexpected error occurred while starting to capture immediates', {
                 cause: err
-            }), "__NEXT_ERROR_CODE", {
-                value: "E964",
-                enumerable: false,
-                configurable: true
             }));
         }
     }
 }
 function expectNoPendingImmediates() {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('expectNoPendingImmediates cannot be called in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E962",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('expectNoPendingImmediates cannot be called in the edge runtime');
     } else {
         if (currentExecution !== null) {
-            bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError(`Expected all captured immediates to have been executed (state: ${ExecutionState[currentExecution.state]})`), "__NEXT_ERROR_CODE", {
-                value: "E958",
-                enumerable: false,
-                configurable: true
-            }));
+            bail(currentExecution, new _invarianterror.InvariantError(`Expected all captured immediates to have been executed (state: ${ExecutionState[currentExecution.state]})`));
+        }
+    }
+}
+const immediateAsyncStorage = (0, _asynclocalstorage.getOrCreateGlobalAsyncLocalStorage)('immediate-async-storage');
+function runWithNativeImmediateTracking(tracker, callback, ...args) {
+    return immediateAsyncStorage.run(tracker, callback, ...args);
+}
+class ImmediateTracker {
+    hasPendingImmediates() {
+        return this.sentinel !== null;
+    }
+    /**
+   * Calls `callback` asynchronously in a native immediate, even when no
+   * immediates are pending. The callback runs in the subscriber's async
+   * context. The returned function cancels the subscription without stopping
+   * tracking.
+   */ onIdle(callback) {
+        const listeners = this.listeners;
+        const listener = (0, _asynclocalstorage.bindSnapshot)(callback);
+        listeners.add(listener);
+        if (this.sentinel === null) {
+            this.scheduleIdleCheck();
+        } else {
+            this.sentinel.ref();
+        }
+        return ()=>{
+            listeners.delete(listener);
+            if (this.listeners.size === 0) {
+                var _this_sentinel;
+                (_this_sentinel = this.sentinel) == null ? void 0 : _this_sentinel.unref();
+            }
+        };
+    }
+    scheduleIdleCheck() {
+        if (this.sentinel !== null) {
+            // New immediates are queued after the pending sentinel. Record that
+            // `checkForIdle` must check again before notifying subscribers. Further
+            // scheduling calls reuse this flag and the pending sentinel.
+            //
+            // Node's uncaught-exception recovery can also reach this branch:
+            //
+            // 1. We queue immediate `A`, then sentinel `S`: `[A, S]`.
+            // 2. `A` throws and interrupts Node's immediate-processing loop,
+            //    leaving `S` first in Node's outstanding queue.
+            // 3. An uncaughtException handler handles the error, so Node continues.
+            // 4. Node calls `timers.setImmediate(noop)` for another immediate cycle.
+            // 5. Our patch runs before async-context cleanup and sees `A`'s tracker.
+            // 6. The tracker finds `S` still pending.
+            //
+            // Node schedules this no-op after any handled uncaught exception so
+            // pending ticks get another chance to run. After exception handling
+            // returns, Node's C++ dispatcher retries the outstanding queue in the
+            // same check phase, before the no-op runs.
+            //
+            // On Node 20, clearing `S` here leaves the outstanding queue's head
+            // pointing to a destroyed immediate. When Node retries the queue, it
+            // tries to skip the cleared entry through its predecessor. The first
+            // entry has no predecessor, so recovery throws another exception. Keep
+            // `S` queued and record that another check is needed instead.
+            this.needsAnotherCheck = true;
+            return;
+        }
+        this.sentinel = originalSetImmediate(this.checkForIdle);
+        if (this.listeners.size === 0) {
+            this.sentinel.unref();
         }
     }
+    constructor(){
+        this.sentinel = null;
+        this.needsAnotherCheck = false;
+        this.listeners = new Set();
+        this.checkForIdle = ()=>{
+            this.sentinel = null;
+            if (this.needsAnotherCheck) {
+                // Schedule the next check after the immediates queued since this
+                // sentinel. Their callbacks and microtasks/nextTicks can then run before
+                // we notify idle subscribers. A synchronous burst shares this next check.
+                this.needsAnotherCheck = false;
+                this.scheduleIdleCheck();
+                return;
+            }
+            const listeners = this.listeners;
+            this.listeners = new Set();
+            for (const callback of listeners){
+                listeners.delete(callback);
+                callback();
+            }
+        };
+    }
 }
 /**
  * Wait until all nextTicks and microtasks spawned from the current task are done,
  * then execute any immediates that they queued.
  * */ function scheduleWorkAfterNextTicksAndMicrotasks(execution) {
     if (execution.state !== 1) {
-        throw Object.defineProperty(new _invarianterror.InvariantError(`scheduleWorkAfterTicksAndMicrotasks can only be called while waiting (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
-            value: "E959",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`scheduleWorkAfterTicksAndMicrotasks can only be called while waiting (state: ${ExecutionState[execution.state]})`);
     }
     // We want to execute "fast immediates" after all the nextTicks and microtasks
     // spawned from the current task are done.
@@ -170,12 +245,8 @@ function expectNoPendingImmediates() {
                 // Otherwise, bail out here (which will trigger an uncaught exception)
                 // Note that we're using the same microtask trick as `safelyRunNextTickCallback`.
                 queueMicrotask(()=>{
-                    bail(execution, Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occurred while executing immediates', {
+                    bail(execution, new _invarianterror.InvariantError('An unexpected error occurred while executing immediates', {
                         cause: err
-                    }), "__NEXT_ERROR_CODE", {
-                        value: "E955",
-                        enumerable: false,
-                        configurable: true
                     }));
                 });
             }
@@ -188,11 +259,7 @@ function expectNoPendingImmediates() {
     }
     debug == null ? void 0 : debug(`scheduler :: performing work`);
     if (execution.state !== 1) {
-        throw Object.defineProperty(new _invarianterror.InvariantError(`performWork can only be called while waiting (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
-            value: "E956",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`performWork can only be called while waiting (state: ${ExecutionState[execution.state]})`);
     }
     execution.state = 2;
     const queueItem = takeNextActiveQueueItem(execution);
@@ -293,11 +360,7 @@ function takeNextActiveQueueItem(execution) {
 }
 function startCapturingImmediates() {
     if (currentExecution !== null) {
-        bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError(`Cannot start capturing immediates again without finishing the previous task (state: ${ExecutionState[currentExecution.state]})`), "__NEXT_ERROR_CODE", {
-            value: "E954",
-            enumerable: false,
-            configurable: true
-        }));
+        bail(currentExecution, new _invarianterror.InvariantError(`Cannot start capturing immediates again without finishing the previous task (state: ${ExecutionState[currentExecution.state]})`));
     }
     wasEnabledAtLeastOnce = true;
     const execution = {
@@ -315,11 +378,7 @@ function stopCapturingImmediates(execution) {
     // to make sure that we've waited for all the nextTicks and microtasks
     // that might've scheduled some immediates after sync code.
     if (execution.state !== 2) {
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot stop capturing immediates before execution is finished (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
-            value: "E957",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Cannot stop capturing immediates before execution is finished (state: ${ExecutionState[execution.state]})`);
     }
     execution.state = 3;
     if (currentExecution === execution) {
@@ -380,11 +439,7 @@ function patchedNextTick() {
         originalNextTick.apply(null, // @ts-expect-error: explicitly passing arguments that we know are invalid
         arguments);
         // We expect the above call to throw. If it didn't, something's broken.
-        bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError('Expected process.nextTick to reject invalid arguments'), "__NEXT_ERROR_CODE", {
-            value: "E966",
-            enumerable: false,
-            configurable: true
-        }));
+        bail(currentExecution, new _invarianterror.InvariantError('Expected process.nextTick to reject invalid arguments'));
     }
     debug == null ? void 0 : debug(`scheduler :: process.nextTick called (previous pending: ${pendingNextTicks})`);
     const callback = arguments[0];
@@ -418,8 +473,11 @@ function safelyRunNextTickCallback(callback, args) {
 }
 function patchedSetImmediate() {
     if (currentExecution === null) {
-        return originalSetImmediate.apply(null, // @ts-expect-error: this is valid, but typescript doesn't get it
+        var _immediateAsyncStorage_getStore;
+        const immediate = originalSetImmediate.apply(null, // @ts-expect-error: this is valid, but typescript doesn't get it
         arguments);
+        (_immediateAsyncStorage_getStore = immediateAsyncStorage.getStore()) == null ? void 0 : _immediateAsyncStorage_getStore.scheduleIdleCheck();
+        return immediate;
     }
     if (arguments.length === 0 || typeof arguments[0] !== 'function') {
         // Let the original setImmediate error for invalid arguments
@@ -427,11 +485,7 @@ function patchedSetImmediate() {
         originalSetImmediate.apply(null, // @ts-expect-error: explicitly passing arguments that we know are invalid
         arguments);
         // We expect the above call to throw. If it didn't, something's broken.
-        bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError('Expected setImmediate to reject invalid arguments'), "__NEXT_ERROR_CODE", {
-            value: "E965",
-            enumerable: false,
-            configurable: true
-        }));
+        bail(currentExecution, new _invarianterror.InvariantError('Expected setImmediate to reject invalid arguments'));
     }
     const callback = arguments[0];
     const args = arguments.length > 1 ? Array.prototype.slice.call(arguments, 1) : null;
@@ -451,7 +505,10 @@ function patchedSetImmediate() {
 }
 function patchedSetImmediatePromise(value, options) {
     if (currentExecution === null) {
-        return originalSetImmediatePromisify(value, options);
+        var _immediateAsyncStorage_getStore;
+        const promise = originalSetImmediatePromisify(value, options);
+        (_immediateAsyncStorage_getStore = immediateAsyncStorage.getStore()) == null ? void 0 : _immediateAsyncStorage_getStore.scheduleIdleCheck();
+        return promise;
     }
     return new Promise((resolve, reject)=>{
         // The abort signal makes the promise reject.
@@ -555,11 +612,7 @@ function proxyQueuedImmediateToNativeImmediate(immediateObject, nativeImmediate)
 // ==========================================
 const debug = process.env.NEXT_DEBUG_IMMEDIATES !== '1' ? undefined : (...args)=>{
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Fast setImmediate is not available in the edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E963",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('Fast setImmediate is not available in the edge runtime.');
     } else {
         const { inspect } = require('node:util');
         const { writeFileSync } = require('node:fs');

package/app/node_modules/next/dist/server/node-environment-extensions/global-behaviors.js

@@ -17,11 +17,7 @@ const _consoledimexternal = require("./console-dim.external");
 function installGlobalBehaviors(config) {
     var _config_experimental;
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected not to install Node.js global behaviors in the edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E874",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('Expected not to install Node.js global behaviors in the edge runtime.');
     }
     if (((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.hideLogsAfterAbort) === true) {
         (0, _consoledimexternal.setAbortedLogsStyle)('hidden');

package/app/node_modules/next/dist/server/node-environment-extensions/io-utils.js

@@ -29,6 +29,7 @@ function io(expression, type) {
                 if (prerenderSignal.aborted === false) {
                     // If the prerender signal is already aborted we don't need to construct
                     // any stacks because something else actually terminated the prerender.
+                    // TODO: synchronize this with `stageController`
                     (0, _dynamicrendering.abortOnSynchronousPlatformIOAccess)(workStore.route, expression, (0, _dynamicrenderingutils.applyOwnerStack)((0, _synciomessages.createSyncIOError)(workStore.route, expression, type)), workUnitStore);
                 }
                 break;
@@ -52,16 +53,21 @@ function io(expression, type) {
                     // `shouldTrackSyncInterrupt`/`syncInterruptCurrentStageWithReason`
                     switch(stageController.currentStage){
                         case _stagedrendering.RenderStage.ShellStatic:
+                        case _stagedrendering.RenderStage.PrefetchStatic_prefetchApi:
+                        case _stagedrendering.RenderStage.PrefetchStatic:
+                        case _stagedrendering.RenderStage.NavigationStatic:
                         case _stagedrendering.RenderStage.Static:
                             {
                                 syncIOError = (0, _synciomessages.createSyncIOError)(workStore.route, expression, type);
                                 break;
                             }
                         case _stagedrendering.RenderStage.ShellRuntime:
-                        case _stagedrendering.RenderStage.Runtime:
+                        case _stagedrendering.RenderStage.PrefetchRuntime_prefetchApi:
+                        case _stagedrendering.RenderStage.PrefetchRuntime:
+                        case _stagedrendering.RenderStage.NavigationRuntime:
                             {
-                                // We're in the Runtime stage.
-                                // We only error for Sync IO in the Runtime stage if the route has partialPrefetching enabled.
+                                // We're in a runtime stage.
+                                // We only error for Sync IO in runtime stages if the route has partialPrefetching enabled.
                                 syncIOError = (0, _synciomessages.createSyncIORuntimeError)(workStore.route, expression, type);
                                 break;
                             }
@@ -69,11 +75,7 @@ function io(expression, type) {
                         case _stagedrendering.RenderStage.Dynamic:
                         case _stagedrendering.RenderStage.Abandoned:
                             {
-                                throw Object.defineProperty(new _invarianterror.InvariantError(`shouldTrackSyncInterrupt allowed a sync IO interrupt in an unexpected stage: ${_stagedrendering.RenderStage[stageController.currentStage]}`), "__NEXT_ERROR_CODE", {
-                                    value: "E1420",
-                                    enumerable: false,
-                                    configurable: true
-                                });
+                                throw new _invarianterror.InvariantError(`shouldTrackSyncInterrupt allowed a sync IO interrupt in an unexpected stage: ${_stagedrendering.RenderStage[stageController.currentStage]}`);
                             }
                     }
                     syncIOError = (0, _dynamicrenderingutils.applyOwnerStack)(syncIOError);
@@ -87,12 +89,11 @@ function io(expression, type) {
                 break;
             }
         case 'validation-client':
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
             break;
         default:
             workUnitStore;

package/app/node_modules/next/dist/server/node-environment-extensions/process-error-handlers.js

@@ -24,7 +24,6 @@ _export(exports, {
         return registerUnhandledRejectionListener;
     }
 });
-const _ispostpone = require("../lib/router-utils/is-postpone");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -73,11 +72,6 @@ let _global = globalThis;
 // bundle) still register and detect a single listener instance.
 const UNHANDLED_REJECTION_LISTENER_KEY = Symbol.for('next.unhandledRejectionListener');
 function unhandledRejectionListener(reason) {
-    if ((0, _ispostpone.isPostpone)(reason)) {
-        // React postpones that are unhandled might end up logged here but they're
-        // not really errors. They're just part of rendering.
-        return;
-    }
     // Immediately log the error.
     // TODO: Ideally, if we knew that this error was triggered by application
     // code, we would suppress it entirely without logging. We can't reliably
@@ -153,9 +147,6 @@ function installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListen
         // is unrelated to the late-awaiting pattern. However, for similar reasons,
         // we still shouldn't crash the process. Just log it.
         process.on('uncaughtException', (reason)=>{
-            if ((0, _ispostpone.isPostpone)(reason)) {
-                return;
-            }
             console.error(reason);
         });
     }

package/app/node_modules/next/dist/server/node-environment-extensions/unhandled-rejection.external.js

@@ -73,22 +73,12 @@ switch(UHR_FILTER_LOG_LEVEL){
 class DebugWithStack extends Error {
     constructor(message){
         super(message);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
         this.name = '[Next.js Unhandled Rejection Filter]';
     }
 }
 class WarnWithStack extends Error {
     constructor(message){
         super(message);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
         this.name = '[Next.js Unhandled Rejection Filter]';
     }
 }
@@ -465,12 +455,11 @@ function filteringUnhandledRejectionHandler(reason, promise) {
                     }
                     break;
                 }
-            case 'prerender-ppr':
             case 'prerender-legacy':
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;

package/app/node_modules/next/dist/server/normalizers/built/app/app-page-normalizer.js

@@ -23,7 +23,7 @@ class DevAppPageNormalizer extends _normalizers.Normalizers {
     constructor(appDir, extensions, _isTurbopack){
         const normalizer = new DevAppPageNormalizerInternal(appDir, extensions);
         super(// %5F to _ replacement should only happen with Turbopack.
-        // TODO: enable when page matcher `/_` check is moved: https://github.com/vercel/next.js/blob/8eda00bf5999e43e8f0211bd72c981d5ce292e8b/packages/next/src/server/route-matcher-providers/dev/dev-app-route-route-matcher-provider.ts#L48
+        // TODO: enable when the dev app file classifier's `/_` check is moved.
         // isTurbopack
         //   ? [
         //       // The page should have the `%5F` characters replaced with `_` characters.

package/app/node_modules/next/dist/server/normalizers/request/base-path.js

@@ -12,11 +12,7 @@ const _prefix = require("./prefix");
 class BasePathPathnameNormalizer extends _prefix.PrefixPathnameNormalizer {
     constructor(basePath){
         if (!basePath || basePath === '/') {
-            throw Object.defineProperty(new Error('Invariant: basePath must be set and cannot be "/"'), "__NEXT_ERROR_CODE", {
-                value: "E154",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Invariant: basePath must be set and cannot be "/"');
         }
         super(basePath);
     }

package/app/node_modules/next/dist/server/normalizers/request/next-data.js

@@ -15,11 +15,7 @@ class NextDataPathnameNormalizer {
     constructor(buildID){
         this.suffix = new _suffix.SuffixPathnameNormalizer('.json');
         if (!buildID) {
-            throw Object.defineProperty(new Error('Invariant: buildID is required'), "__NEXT_ERROR_CODE", {
-                value: "E200",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Invariant: buildID is required');
         }
         this.prefix = new _prefix.PrefixPathnameNormalizer(`/_next/data/${buildID}`);
     }

package/app/node_modules/next/dist/server/normalizers/request/prefix.js

@@ -12,11 +12,7 @@ class PrefixPathnameNormalizer {
     constructor(prefix){
         this.prefix = prefix;
         if (prefix.endsWith('/')) {
-            throw Object.defineProperty(new Error(`PrefixPathnameNormalizer: prefix "${prefix}" should not end with a slash`), "__NEXT_ERROR_CODE", {
-                value: "E219",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`PrefixPathnameNormalizer: prefix "${prefix}" should not end with a slash`);
         }
     }
     match(pathname) {