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

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

package/.next/standalone/node_modules/next/dist/server/og/cache-image-response.js

@@ -49,9 +49,8 @@ async function getCachedImageResponseArrayBuffer(args) {
         case 'prerender-runtime':
         case 'prerender-client':
         case 'validation-client':
-        case 'prerender-ppr':
         case 'prerender-legacy':
-        case 'generate-static-params':
+        case 'build-time-generator':
             return renderImageResponseArrayBuffer(args);
         default:
             return workUnitStore;
@@ -62,11 +61,7 @@ async function getCachedImageResponseArrayBuffer(args) {
     }
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected a work store while caching an `ImageResponse` during prerendering.'), "__NEXT_ERROR_CODE", {
-            value: "E1382",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('Expected a work store while caching an `ImageResponse` during prerendering.');
     }
     const [element, options] = args;
     // `createHangingInputAbortSignal` aborts once the prerender's cache-sourced

package/.next/standalone/node_modules/next/dist/server/patch-error-inspect.js

@@ -108,7 +108,7 @@ function setCodeFrameRenderer(renderer) {
     ;
     globalThis[CODE_FRAME_RENDERER] = renderer;
 }
-function getOriginalCodeFrame(frame, source, colors = process.stdout.isTTY) {
+function getOriginalCodeFrame(frame, source, colors = _picocolors.stdoutIsTerminal) {
     const codeFrameRenderer = globalThis[CODE_FRAME_RENDERER];
     if (!codeFrameRenderer) {
         // No renderer available - gracefully degrade
@@ -431,15 +431,7 @@ function sourceMapError(error, inspectOptions) {
     } : undefined;
     // Create a new Error object with the source mapping applied and then use native
     // Node.js formatting on the result.
-    const newError = error instanceof AggregateError ? Object.defineProperty(new AggregateError(error.errors, error.message, options), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    }) : Object.defineProperty(new Error(error.message, options), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    });
+    const newError = error instanceof AggregateError ? new AggregateError(error.errors, error.message, options) : new Error(error.message, options);
     // TODO: Ensure `class MyError extends Error {}` prints `MyError` as the name
     newError.stack = parseAndSourceMap(error, inspectOptions);
     for(const key in error){
@@ -451,6 +443,22 @@ function sourceMapError(error, inspectOptions) {
     }
     return newError;
 }
+/**
+ * Node.js passes the remaining depth in `depth`. An `AggregateError` keeps its
+ * errors in an array. Node.js spends one level of the depth on that array, and
+ * one more level on each error in the array. A `cause` costs one level only.
+ * This function adds the missing level back, so an `AggregateError` prints its
+ * errors at the same nesting as a `cause`. Without it, a `fetch` failure logs
+ * `[errors]: [ [Error], [Error] ]` and hides the address and the port of every
+ * refused connection.
+ *
+ * A `depth` of `null` means unlimited, so this function returns it unchanged.
+ */ function getInspectDepth(error, depth) {
+    if (depth === null || !(error instanceof AggregateError)) {
+        return depth;
+    }
+    return depth + 1;
+}
 function patchErrorInspectNodeJS(errorConstructor) {
     const inspectSymbol = Symbol.for('nodejs.util.inspect.custom');
     errorConstructor.prepareStackTrace = prepareUnsourcemappedStackTrace;
@@ -470,7 +478,7 @@ function patchErrorInspectNodeJS(errorConstructor) {
             try {
                 return inspect(newError, {
                     ...inspectOptions,
-                    depth
+                    depth: getInspectDepth(newError, depth)
                 });
             } finally{
                 ;