@aeolus-fleet/console 0.35.0 → 0.36.1

package/.next/standalone/node_modules/next/dist/server/dev/hot-reloader-types.js

@@ -41,7 +41,9 @@ var HMR_MESSAGE_SENT_TO_BROWSER = /*#__PURE__*/ function(HMR_MESSAGE_SENT_TO_BRO
     HMR_MESSAGE_SENT_TO_BROWSER["CACHE_INDICATOR"] = "cacheIndicator";
     HMR_MESSAGE_SENT_TO_BROWSER["DEV_INDICATOR"] = "devIndicator";
     HMR_MESSAGE_SENT_TO_BROWSER["DEVTOOLS_CONFIG"] = "devtoolsConfig";
+    HMR_MESSAGE_SENT_TO_BROWSER["VULNERABILITY_INSIGHT"] = "vulnerabilityInsight";
     HMR_MESSAGE_SENT_TO_BROWSER["REQUEST_CURRENT_ERROR_STATE"] = "requestCurrentErrorState";
+    HMR_MESSAGE_SENT_TO_BROWSER["RUNTIME_ERRORS"] = "runtimeErrors";
     HMR_MESSAGE_SENT_TO_BROWSER["REQUEST_PAGE_METADATA"] = "requestPageMetadata";
     HMR_MESSAGE_SENT_TO_BROWSER["REQUEST_INSIGHTS_UPDATE"] = "requestInsightsUpdate";
     // Binary messages:
@@ -52,6 +54,7 @@ var HMR_MESSAGE_SENT_TO_BROWSER = /*#__PURE__*/ function(HMR_MESSAGE_SENT_TO_BRO
 var HMR_MESSAGE_SENT_TO_SERVER = /*#__PURE__*/ function(HMR_MESSAGE_SENT_TO_SERVER) {
     // JSON messages:
     HMR_MESSAGE_SENT_TO_SERVER["MCP_ERROR_STATE_RESPONSE"] = "mcp-error-state-response";
+    HMR_MESSAGE_SENT_TO_SERVER["RUNTIME_ERRORS"] = "runtimeErrors";
     HMR_MESSAGE_SENT_TO_SERVER["MCP_PAGE_METADATA_RESPONSE"] = "mcp-page-metadata-response";
     HMR_MESSAGE_SENT_TO_SERVER["PING"] = "ping";
     return HMR_MESSAGE_SENT_TO_SERVER;

package/.next/standalone/node_modules/next/dist/server/dev/hot-reloader-webpack.js

@@ -24,6 +24,7 @@ const _webpack = require("next/dist/compiled/webpack/webpack");
 const _middlewarewebpack = require("./middleware-webpack");
 const _hotmiddleware = require("./hot-middleware");
 const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
+const _crypto = require("crypto");
 const _path = require("path");
 const _entries = require("../../build/entries");
 const _routediscovery = require("../../build/route-discovery");
@@ -52,7 +53,6 @@ const _routekind = require("../route-kind");
 const _hotreloadertypes = require("./hot-reloader-types");
 const _pagetypes = require("../../lib/page-types");
 const _messages = require("./messages");
-const _getnexterrorfeedbackmiddleware = require("../../next-devtools/server/get-next-error-feedback-middleware");
 const _getdevoverlayfontmiddleware = require("../../next-devtools/server/font/get-dev-overlay-font-middleware");
 const _devindicatormiddleware = require("../../next-devtools/server/dev-indicator-middleware");
 const _getwebpackbundler = /*#__PURE__*/ _interop_require_default(require("../../shared/lib/get-webpack-bundler"));
@@ -124,6 +124,8 @@ function diff(a, b) {
 const wsServer = new _ws.default.Server({
     noServer: true
 });
+// Folded into the HMR refresh hash to make it differ between dev server runs.
+const devServerSessionId = (0, _crypto.randomUUID)();
 async function renderScriptError(res, error, { verbose = true } = {}) {
     // Asks CDNs and others to not to cache the errored page
     res.setHeader('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate');
@@ -202,7 +204,7 @@ function erroredPages(compilation) {
     return failedPages;
 }
 class HotReloaderWebpack {
-    constructor(dir, { config, isSrcDir, pagesDir, distDir, buildId, encryptionKey, previewProps, rewrites, appDir, telemetry, resetFetch, lockfile, onDevServerCleanup }){
+    constructor(dir, { config, isSrcDir, pagesDir, distDir, buildId, encryptionKey, previewProps, rewrites, appDir, telemetry, resetFetch, lockfile, onDevServerCleanup, hasVulnerabilityInsight }){
         this.clientError = null;
         this.serverError = null;
         this.hmrServerError = null;
@@ -230,11 +232,12 @@ class HotReloaderWebpack {
         this.telemetry = telemetry;
         this.resetFetch = resetFetch;
         this.lockfile = lockfile;
+        this.hasVulnerabilityInsight = hasVulnerabilityInsight;
         this.config = config;
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "16.3.8"
+            version: "16.4.2"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.
@@ -270,11 +273,7 @@ class HotReloaderWebpack {
             try {
                 decodedPagePath = `/${params.path.map((param)=>decodeURIComponent(param)).join('/')}`;
             } catch (_) {
-                throw Object.defineProperty(new _utils1.DecodeError('failed to decode param'), "__NEXT_ERROR_CODE", {
-                    value: "E528",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _utils1.DecodeError('failed to decode param');
             }
             const page = (0, _denormalizepagepath.denormalizePagePath)(decodedPagePath);
             if (page === '/_error' || _constants1.BLOCKED_PAGES.indexOf(page) === -1) {
@@ -331,21 +330,17 @@ class HotReloaderWebpack {
         });
     }
     getServerComponentsHmrRefreshHash() {
-        return this.serverComponentsHmrRefreshHash;
+        return `${devServerSessionId}-${this.serverComponentsHmrRefreshHash ?? '0'}`;
     }
     onHMR(req, _socket, head, callback) {
         wsServer.handleUpgrade(req, req.socket, head, (client)=>{
             var _this_onDemandEntries;
             const htmlRequestId = req.url ? new URL(req.url, 'http://n').searchParams.get('id') : null;
             if (!this.webpackHotMiddleware) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Did not start HotReloaderWebpack.'), "__NEXT_ERROR_CODE", {
-                    value: "E804",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Did not start HotReloaderWebpack.');
             }
             this.webpackHotMiddleware.onHMR(client, htmlRequestId);
-            (_this_onDemandEntries = this.onDemandEntries) == null ? void 0 : _this_onDemandEntries.onHMR(client, ()=>this.hmrServerError);
+            (_this_onDemandEntries = this.onDemandEntries) == null ? void 0 : _this_onDemandEntries.onHMR(client, ()=>this.hmrServerError, htmlRequestId);
             const enableCacheComponents = this.config.cacheComponents;
             // Clients with a request ID are inferred App Router clients. If Cache
             // Components is not enabled, we consider those legacy clients. Pages
@@ -522,7 +517,10 @@ class HotReloaderWebpack {
         });
     }
     async clean(span) {
-        return span.traceChild('clean').traceAsyncFn(()=>(0, _recursivedelete.recursiveDeleteSyncWithAsyncRetries)((0, _path.join)(this.dir, this.config.distDir), /^(cache|lock)/));
+        return span.traceChild('clean').traceAsyncFn(()=>(0, _recursivedelete.recursiveDeleteSyncWithAsyncRetries)((0, _path.join)(this.dir, this.config.distDir), new Set([
+                'cache',
+                'lock'
+            ])));
     }
     async getWebpackConfig(span) {
         const webpackConfigSpan = span.traceChild('get-webpack-config');
@@ -751,6 +749,8 @@ class HotReloaderWebpack {
                         this.hasAppRouterEntrypoints = true;
                     }
                     const isInstrumentation = (0, _utils.isInstrumentationHookFile)(page) && pageType === _pagetypes.PAGE_TYPES.ROOT;
+                    const entryAppPaths = 'appPaths' in entryData ? entryData.appPaths : null;
+                    const isFinalRouteMatcher = pageType === _pagetypes.PAGE_TYPES.APP && this.config.experimental.strictRouteMatching && !!(entryAppPaths == null ? void 0 : entryAppPaths.length);
                     let pageRuntime = staticInfo == null ? void 0 : staticInfo.runtime;
                     (0, _entries.runDependingOnPageType)({
                         page,
@@ -791,7 +791,10 @@ class HotReloaderWebpack {
                                 nextConfigOutput: this.config.output,
                                 preferredRegion: staticInfo == null ? void 0 : staticInfo.preferredRegion,
                                 middlewareConfig: Buffer.from(JSON.stringify((staticInfo == null ? void 0 : staticInfo.middleware) || {})).toString('base64'),
-                                isGlobalNotFoundEnabled: this.config.experimental.globalNotFound ? true : undefined
+                                isGlobalNotFoundEnabled: this.config.experimental.globalNotFound ? true : undefined,
+                                explicitParallelRouteChildren: this.config.experimental.explicitParallelRouteChildren ? true : undefined,
+                                strictRouteMatching: this.config.experimental.strictRouteMatching ? true : undefined,
+                                isFinalRouteMatcher: isFinalRouteMatcher ? true : undefined
                             }).import : undefined;
                             entrypoints[bundlePath] = (0, _entries.finalizeEntrypoint)({
                                 compilerType: _constants1.COMPILER_NAMES.edgeServer,
@@ -891,7 +894,10 @@ class HotReloaderWebpack {
                                     nextConfigOutput: this.config.output,
                                     preferredRegion: staticInfo == null ? void 0 : staticInfo.preferredRegion,
                                     middlewareConfig: Buffer.from(JSON.stringify((staticInfo == null ? void 0 : staticInfo.middleware) || {})).toString('base64'),
-                                    isGlobalNotFoundEnabled: this.config.experimental.globalNotFound ? true : undefined
+                                    isGlobalNotFoundEnabled: this.config.experimental.globalNotFound ? true : undefined,
+                                    explicitParallelRouteChildren: this.config.experimental.explicitParallelRouteChildren ? true : undefined,
+                                    strictRouteMatching: this.config.experimental.strictRouteMatching ? true : undefined,
+                                    isFinalRouteMatcher: isFinalRouteMatcher ? true : undefined
                                 });
                             } else if ((0, _isapiroute.isAPIRoute)(page)) {
                                 value = (0, _nextrouteloader.getRouteLoaderEntry)({
@@ -1176,7 +1182,7 @@ class HotReloaderWebpack {
             }
             this.prevChunkNames = chunkNames;
         });
-        this.webpackHotMiddleware = new _hotmiddleware.WebpackHotMiddleware(this.multiCompiler.compilers, this.versionInfo, this.devtoolsFrontendUrl, this.config, initialDevToolsConfig);
+        this.webpackHotMiddleware = new _hotmiddleware.WebpackHotMiddleware(this.multiCompiler.compilers, this.versionInfo, this.devtoolsFrontendUrl, this.config, initialDevToolsConfig, this.hasVulnerabilityInsight);
         let booted = false;
         this.watcher = await new Promise((resolve)=>{
             var _this_multiCompiler;
@@ -1208,7 +1214,7 @@ class HotReloaderWebpack {
             clientStats: ()=>this.clientStats,
             serverStats: ()=>this.serverStats,
             edgeServerStats: ()=>this.edgeServerStats
-        }), (0, _getnexterrorfeedbackmiddleware.getNextErrorFeedbackMiddleware)(this.telemetry), (0, _getdevoverlayfontmiddleware.getDevOverlayFontMiddleware)(), (0, _devindicatormiddleware.getDisableDevIndicatorMiddleware)(), (0, _restartdevservermiddleware.getRestartDevServerMiddleware)({
+        }), (0, _getdevoverlayfontmiddleware.getDevOverlayFontMiddleware)(), (0, _devindicatormiddleware.getDisableDevIndicatorMiddleware)(), (0, _restartdevservermiddleware.getRestartDevServerMiddleware)({
             telemetry: this.telemetry,
             webpackCacheDirectories: this.activeWebpackConfigs != null ? (0, _webpackconfig.getCacheDirectories)(this.activeWebpackConfigs) : undefined
         }), (0, _devtoolsconfigmiddleware.devToolsConfigMiddleware)({

package/.next/standalone/node_modules/next/dist/server/dev/messages.js

@@ -42,11 +42,7 @@ function createBinaryHmrMessageData(message) {
                 const requestIdBytes = textEncoder.encode(requestId);
                 const requestIdLength = requestIdBytes.length;
                 if (requestIdLength > 255) {
-                    throw Object.defineProperty(new _invarianterror.InvariantError('Request ID is too long for the binary HMR message.'), "__NEXT_ERROR_CODE", {
-                        value: "E805",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new _invarianterror.InvariantError('Request ID is too long for the binary HMR message.');
                 }
                 const chunkLength = chunk ? chunk.length : 0;
                 const totalLength = 2 + requestIdLength + chunkLength;
@@ -62,11 +58,7 @@ function createBinaryHmrMessageData(message) {
             }
         default:
             {
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid binary HMR message of type ${message.type}`), "__NEXT_ERROR_CODE", {
-                    value: "E809",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Invalid binary HMR message of type ${message.type}`);
             }
     }
 }

package/.next/standalone/node_modules/next/dist/server/dev/middleware-turbopack.js

@@ -166,12 +166,8 @@ function createStackFrame(searchParams) {
         var _findSourceMap;
         sourceMapPayload = (_findSourceMap = (0, _nodemodule.findSourceMap)(sourceURL)) == null ? void 0 : _findSourceMap.payload;
     } catch (cause) {
-        throw Object.defineProperty(new Error(`${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
+        throw new Error(`${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
             cause
-        }), "__NEXT_ERROR_CODE", {
-            value: "E635",
-            enumerable: false,
-            configurable: true
         });
     }
     if (sourceMapPayload !== undefined) {
@@ -179,12 +175,8 @@ function createStackFrame(searchParams) {
         try {
             consumer = await new _sourcemap08.SourceMapConsumer(sourceMapPayload);
         } catch (cause) {
-            throw Object.defineProperty(new Error(`${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
+            throw new Error(`${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
                 cause
-            }), "__NEXT_ERROR_CODE", {
-                value: "E635",
-                enumerable: false,
-                configurable: true
             });
         }
         let traced;
@@ -346,12 +338,8 @@ function getSourceMapMiddleware(project) {
         try {
             nativeSourceMap = (0, _nodemodule.findSourceMap)(filename);
         } catch (cause) {
-            return _middlewareresponse.middlewareResponse.internalServerError(res, Object.defineProperty(new Error(`${filename}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
+            return _middlewareresponse.middlewareResponse.internalServerError(res, new Error(`${filename}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
                 cause
-            }), "__NEXT_ERROR_CODE", {
-                value: "E635",
-                enumerable: false,
-                configurable: true
             }));
         }
         if (nativeSourceMap !== undefined) {
@@ -373,12 +361,8 @@ function getSourceMapMiddleware(project) {
                 return _middlewareresponse.middlewareResponse.jsonString(res, sourceMapString);
             }
         } catch (cause) {
-            return _middlewareresponse.middlewareResponse.internalServerError(res, Object.defineProperty(new Error(`Failed to get source map for '${filename}'. This is a bug in Next.js`, {
+            return _middlewareresponse.middlewareResponse.internalServerError(res, new Error(`Failed to get source map for '${filename}'. This is a bug in Next.js`, {
                 cause
-            }), "__NEXT_ERROR_CODE", {
-                value: "E719",
-                enumerable: false,
-                configurable: true
             }));
         }
         _middlewareresponse.middlewareResponse.noContent(res);

package/.next/standalone/node_modules/next/dist/server/dev/middleware-webpack.js

@@ -75,12 +75,8 @@ function getSourcePath(source) {
     try {
         consumer = await new _sourcemap08.SourceMapConsumer(sourceMap);
     } catch (cause) {
-        console.error(Object.defineProperty(new Error(`${sourceMap.file}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
+        console.error(new Error(`${sourceMap.file}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
             cause
-        }), "__NEXT_ERROR_CODE", {
-            value: "E635",
-            enumerable: false,
-            configurable: true
         }));
         return null;
     }
@@ -219,12 +215,8 @@ async function getSource(frame, options) {
     try {
         nativeSourceMap = (0, _module.findSourceMap)(sourceURL);
     } catch (cause) {
-        throw Object.defineProperty(new Error(`${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
+        throw new Error(`${sourceURL}: Invalid source map. Only conformant source maps can be used to find the original code.`, {
             cause
-        }), "__NEXT_ERROR_CODE", {
-            value: "E635",
-            enumerable: false,
-            configurable: true
         });
     }
     if (nativeSourceMap !== undefined) {

package/.next/standalone/node_modules/next/dist/server/dev/node-stack-frames.js

@@ -28,34 +28,17 @@ function getServerError(error, type) {
     if (error.name === 'TurbopackInternalError') {
         // If this is an internal Turbopack error we shouldn't show internal details
         // to the user. These are written to a log file instead.
-        const turbopackInternalError = Object.defineProperty(new Error('An unexpected Turbopack error occurred. Please see the output of `next dev` for more details.'), "__NEXT_ERROR_CODE", {
-            value: "E167",
-            enumerable: false,
-            configurable: true
-        });
+        const turbopackInternalError = new Error('An unexpected Turbopack error occurred. Please see the output of `next dev` for more details.');
         (0, _errorsource.decorateServerError)(turbopackInternalError, type);
         return turbopackInternalError;
     }
     let n;
     try {
-        throw Object.defineProperty(new Error(error.message), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(error.message);
     } catch (e) {
         n = e;
     }
     n.name = error.name;
-    // If present, restore the error code from the original server error.
-    const errorCode = error.__NEXT_ERROR_CODE;
-    if (typeof errorCode === 'string') {
-        Object.defineProperty(n, '__NEXT_ERROR_CODE', {
-            value: errorCode,
-            enumerable: false,
-            configurable: true
-        });
-    }
     try {
         n.stack = `${n.toString()}\n${(0, _stacktraceparser.parse)(error.stack).map(getFilesystemFrame).map((f)=>{
             let str = `    at ${f.methodName}`;

package/.next/standalone/node_modules/next/dist/server/dev/on-demand-entry-handler.js

@@ -73,6 +73,7 @@ const _pagetypes = require("../../lib/page-types");
 const _flightdatahelpers = require("../../client/flight-data-helpers");
 const _geterrors = require("../mcp/tools/get-errors");
 const _getpagemetadata = require("../mcp/tools/get-page-metadata");
+const _runtimeerrorstate = require("./runtime-error-state");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -111,11 +112,7 @@ function convertDynamicParamTypeToSyntax(dynamicParamTypeShort, param) {
         case 'di(...)':
             return `[${param}]`;
         default:
-            throw Object.defineProperty(new Error('Unknown dynamic param type'), "__NEXT_ERROR_CODE", {
-                value: "E378",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Unknown dynamic param type');
     }
 }
 function getEntryKey(compilerType, pageBundleType, page) {
@@ -133,7 +130,7 @@ function getPageBundleType(pageBundlePath) {
 function getEntrypointsFromTree(tree, isFirst, parentPath = []) {
     const [segment, parallelRoutes] = tree;
     const currentSegment = Array.isArray(segment) ? convertDynamicParamTypeToSyntax(segment[2], segment[0]) : segment;
-    const isPageSegment = currentSegment.startsWith(_segment.PAGE_SEGMENT_KEY);
+    const isPageSegment = currentSegment === _segment.PAGE_SEGMENT_KEY;
     const currentPath = [
         ...parentPath,
         isPageSegment ? '' : currentSegment
@@ -569,11 +566,7 @@ function onDemandEntryHandler({ hotReloader, maxInactiveAge, multiCompiler, next
             }
             if (typeof isApp === 'boolean' && isApp !== isInsideAppDir) {
                 Error.stackTraceLimit = 15;
-                throw Object.defineProperty(new Error(`Ensure bailed, found path "${route.page}" does not match ensure type (${isApp ? 'app' : 'pages'})`), "__NEXT_ERROR_CODE", {
-                    value: "E419",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Ensure bailed, found path "${route.page}" does not match ensure type (${isApp ? 'app' : 'pages'})`);
             }
             const pageBundleType = getPageBundleType(route.bundlePath);
             const addEntry = (compilerType)=>{
@@ -736,10 +729,15 @@ function onDemandEntryHandler({ hotReloader, maxInactiveAge, multiCompiler, next
                 });
             });
         },
-        onHMR (client, getHmrServerError) {
+        onHMR (client, getHmrServerError, htmlRequestId) {
             let bufferedHmrServerError = null;
+            const runtimeErrorStateHandler = nextConfig.experimental.exposeRuntimeErrorsToHMR || Boolean(process.env.__NEXT_EXPOSE_RUNTIME_ERRORS_TO_HMR) ? (0, _runtimeerrorstate.createRuntimeErrorStateHandler)((message)=>hotReloader.send({
+                    ...message,
+                    htmlRequestId
+                })) : undefined;
             client.addEventListener('close', ()=>{
                 bufferedHmrServerError = null;
+                runtimeErrorStateHandler == null ? void 0 : runtimeErrorStateHandler.dispose();
             });
             client.addEventListener('message', ({ data })=>{
                 try {
@@ -759,6 +757,8 @@ function onDemandEntryHandler({ hotReloader, maxInactiveAge, multiCompiler, next
                         } else {
                             handlePing(parsedData.page);
                         }
+                    } else if (parsedData.event === _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.RUNTIME_ERRORS) {
+                        void (runtimeErrorStateHandler == null ? void 0 : runtimeErrorStateHandler.handle(parsedData).catch(()=>{}));
                     } else if (parsedData.event === _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.MCP_ERROR_STATE_RESPONSE) {
                         (0, _geterrors.handleErrorStateResponse)(parsedData.requestId, parsedData.errorState, parsedData.url);
                     } else if (parsedData.event === _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.MCP_PAGE_METADATA_RESPONSE) {

package/.next/standalone/node_modules/next/dist/server/dev/runtime-error-state.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createRuntimeErrorStateHandler: null,
+    formatRuntimeErrors: null,
+    isRuntimeErrorStateUpdate: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createRuntimeErrorStateHandler: function() {
+        return createRuntimeErrorStateHandler;
+    },
+    formatRuntimeErrors: function() {
+        return formatRuntimeErrors;
+    },
+    isRuntimeErrorStateUpdate: function() {
+        return isRuntimeErrorStateUpdate;
+    }
+});
+const _crypto = require("crypto");
+const _hotreloadertypes = require("./hot-reloader-types");
+const _formaterrors = require("../mcp/tools/utils/format-errors");
+const formatStackFrameToObject = (frame)=>{
+    return {
+        file: frame.file || '<unknown>',
+        methodName: frame.methodName || '<anonymous>',
+        line: frame.line1,
+        column: frame.column1
+    };
+};
+const resolveErrorFrames = async (frames, context)=>{
+    try {
+        const resolvedFrames = await (0, _formaterrors.resolveStackFrames)({
+            frames: frames.map((frame)=>({
+                    file: frame.file || null,
+                    methodName: frame.methodName || '<anonymous>',
+                    arguments: [],
+                    line1: frame.line1 || null,
+                    column1: frame.column1 || null
+                })),
+            isServer: context.isServer,
+            isEdgeServer: context.isEdgeServer,
+            isAppDirectory: context.isAppDirectory
+        });
+        return resolvedFrames.flatMap((resolvedFrame, index)=>{
+            var _resolvedFrame_value_originalStackFrame;
+            if (resolvedFrame.status === 'fulfilled' && ((_resolvedFrame_value_originalStackFrame = resolvedFrame.value.originalStackFrame) == null ? void 0 : _resolvedFrame_value_originalStackFrame.ignored)) {
+                return [];
+            }
+            return [
+                resolvedFrame.status === 'fulfilled' && resolvedFrame.value.originalStackFrame ? formatStackFrameToObject(resolvedFrame.value.originalStackFrame) : formatStackFrameToObject(frames[index])
+            ];
+        });
+    } catch  {
+        return frames.map(formatStackFrameToObject);
+    }
+};
+async function formatRuntimeErrors(errors, isAppDirectory) {
+    const formattedErrors = [];
+    for (const error of errors){
+        var _error_error, _error_error1, _error_frames;
+        const errorName = ((_error_error = error.error) == null ? void 0 : _error_error.name) || 'Error';
+        const message = ((_error_error1 = error.error) == null ? void 0 : _error_error1.message) || 'Unknown error';
+        let stack = [];
+        if ((_error_frames = error.frames) == null ? void 0 : _error_frames.length) {
+            var _error_error2;
+            const errorSource = (_error_error2 = error.error) == null ? void 0 : _error_error2.source;
+            stack = await resolveErrorFrames(error.frames, {
+                isServer: errorSource === 'server',
+                isEdgeServer: errorSource === 'edge-server',
+                isAppDirectory
+            });
+        }
+        formattedErrors.push({
+            type: error.type,
+            errorName,
+            message,
+            fatal: error.fatal,
+            ...error.boundary ? {
+                boundary: error.boundary
+            } : {},
+            stack
+        });
+    }
+    return formattedErrors;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isNullableString(value) {
+    return value === null || typeof value === 'string';
+}
+function isNullableNumber(value) {
+    return value === null || typeof value === 'number' && Number.isFinite(value);
+}
+function isRuntimeErrorStateError(value) {
+    if (!isRecord(value) || typeof value.id !== 'number' || !Number.isFinite(value.id) || value.type !== 'runtime' && value.type !== 'recoverable' && value.type !== 'console' || typeof value.fatal !== 'boolean' || value.boundary !== undefined && (!isRecord(value.boundary) || ![
+        'default-global',
+        'custom-global',
+        'custom'
+    ].includes(value.boundary.kind) || value.boundary.name !== undefined && typeof value.boundary.name !== 'string') || !Array.isArray(value.frames)) {
+        return false;
+    }
+    if (value.error !== null) {
+        if (!isRecord(value.error)) {
+            return false;
+        }
+        if (value.error.name !== undefined && typeof value.error.name !== 'string' || value.error.message !== undefined && typeof value.error.message !== 'string' || value.error.stack !== undefined && typeof value.error.stack !== 'string' || value.error.source !== null && value.error.source !== 'server' && value.error.source !== 'edge-server') {
+            return false;
+        }
+    }
+    return value.frames.every((frame)=>isRecord(frame) && isNullableString(frame.file) && typeof frame.methodName === 'string' && isNullableNumber(frame.line1) && isNullableNumber(frame.column1));
+}
+function isRuntimeErrorStateUpdate(value) {
+    if (!isRecord(value) || value.event !== _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.RUNTIME_ERRORS || typeof value.pathname !== 'string' || !value.pathname.startsWith('/') || value.pathname.includes('?') || value.pathname.includes('#') || !isRecord(value.errorState) || !Array.isArray(value.errorState.errors) || value.errorState.routerType !== 'app') {
+        return false;
+    }
+    return value.errorState.errors.every(isRuntimeErrorStateError);
+}
+function createRuntimeErrorStateHandler(sendHmrMessage, format = formatRuntimeErrors, clientId = (0, _crypto.randomUUID)()) {
+    let generation = 0;
+    let disposed = false;
+    let lastPublishedMessage = null;
+    const formattedErrorCache = new Map();
+    async function formatWithCache(errors, isAppDirectory) {
+        const keys = errors.map((error)=>`${isAppDirectory ? 'app' : 'pages'}:${JSON.stringify(error)}`);
+        const activeKeys = new Set(keys);
+        const pending = [];
+        const missing = [];
+        for(let index = 0; index < errors.length; index++){
+            const key = keys[index];
+            const cached = formattedErrorCache.get(key);
+            if (cached) {
+                pending[index] = cached;
+            } else {
+                missing.push({
+                    error: errors[index],
+                    key,
+                    outputIndex: index
+                });
+            }
+        }
+        if (missing.length > 0) {
+            const batch = format(missing.map(({ error })=>error), isAppDirectory);
+            for(let index = 0; index < missing.length; index++){
+                const { key, outputIndex } = missing[index];
+                const formatted = batch.then((result)=>{
+                    const error = result[index];
+                    if (!error) {
+                        throw new Error('Runtime error formatter returned no result');
+                    }
+                    return error;
+                }).catch((error)=>{
+                    if (formattedErrorCache.get(key) === formatted) {
+                        formattedErrorCache.delete(key);
+                    }
+                    throw error;
+                });
+                formattedErrorCache.set(key, formatted);
+                pending[outputIndex] = formatted;
+            }
+        }
+        for (const key of formattedErrorCache.keys()){
+            if (!activeKeys.has(key)) {
+                formattedErrorCache.delete(key);
+            }
+        }
+        return Promise.all(pending.map((formatted)=>{
+            if (!formatted) {
+                throw new Error('Runtime error formatter cache is incomplete');
+            }
+            return formatted;
+        }));
+    }
+    return {
+        async handle (update) {
+            if (disposed || !isRuntimeErrorStateUpdate(update)) {
+                return;
+            }
+            const currentGeneration = ++generation;
+            const errors = await formatWithCache(update.errorState.errors, update.errorState.routerType === 'app');
+            if (disposed || currentGeneration !== generation) {
+                return;
+            }
+            const message = {
+                type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.RUNTIME_ERRORS,
+                clientId,
+                pathname: update.pathname,
+                errors
+            };
+            sendHmrMessage(message);
+            lastPublishedMessage = message;
+        },
+        dispose () {
+            if (disposed) {
+                return;
+            }
+            const clearMessage = lastPublishedMessage && lastPublishedMessage.errors.length > 0 ? {
+                ...lastPublishedMessage,
+                errors: []
+            } : null;
+            disposed = true;
+            generation++;
+            formattedErrorCache.clear();
+            lastPublishedMessage = null;
+            if (clearMessage) {
+                sendHmrMessage(clearMessage);
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=runtime-error-state.js.map

package/.next/standalone/node_modules/next/dist/server/dev/serialized-errors.js

@@ -38,12 +38,8 @@ function sendSerializedErrorsToClient(errorsRscStream, sendToClient) {
             serializedErrors
         });
     }, (err)=>{
-        console.error(Object.defineProperty(new Error('Failed to serialize errors.', {
+        console.error(new Error('Failed to serialize errors.', {
             cause: err
-        }), "__NEXT_ERROR_CODE", {
-            value: "E948",
-            enumerable: false,
-            configurable: true
         }));
     });
 }