@vectorize-io/hindsight-control-plane 0.2.1 → 0.3.0

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

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Rspack Persistent Cache Strategy for Next.js Development
+ *
+ * Rspack's persistent caching differs from Webpack in how it manages module graphs.
+ * While Webpack incrementally updates modules, Rspack operates on complete module
+ * graph snapshots for cache restoration.
+ *
+ * Problem:
+ * - Next.js dev server starts with no page modules in the initial entry points
+ * - When Rspack restores from persistent cache, it finds no modules and purges
+ *   the entire module graph
+ * - Later page requests find no cached module information, preventing cache reuse
+ *
+ * Solution:
+ * - Track successfully built page entries after each compilation
+ * - Restore these entries on dev server restart to maintain module graph continuity
+ * - This ensures previously compiled pages can leverage persistent cache for faster builds
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return HotReloaderRspack;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _crypto = require("crypto");
+const _hotreloaderwebpack = /*#__PURE__*/ _interop_require_default(require("./hot-reloader-webpack"));
+const _ondemandentryhandler = require("./on-demand-entry-handler");
+const _constants = require("../../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class HotReloaderRspack extends _hotreloaderwebpack.default {
+    async afterCompile(multiCompiler) {
+        // Always initialize the fallback error watcher for Rspack.
+        // Rspack may restore/retain the previous build's error state, so without this
+        // a page that previously failed to build might not be rebuilt on the next request.
+        await super.buildFallbackError();
+        const rspackStartSpan = this.hotReloaderSpan.traceChild('rspack-after-compile');
+        await rspackStartSpan.traceAsyncFn(async ()=>{
+            const hash = (0, _crypto.createHash)('sha1');
+            multiCompiler.compilers.forEach((compiler)=>{
+                const cache = compiler.options.cache;
+                if (typeof cache === 'object' && 'version' in cache && cache.version) {
+                    hash.update(cache.version);
+                    if (compiler.name === _constants.COMPILER_NAMES.client) {
+                        this.isClientCacheEnabled = true;
+                    } else if (compiler.name === _constants.COMPILER_NAMES.server) {
+                        this.isServerCacheEnabled = true;
+                    } else if (compiler.name === _constants.COMPILER_NAMES.edgeServer) {
+                        this.isEdgeServerCacheEnabled = true;
+                    }
+                } else {
+                    hash.update('-');
+                }
+                return undefined;
+            });
+            this.builtEntriesCachePath = _path.default.join(this.distDir, 'cache', 'rspack', hash.digest('hex').substring(0, 16), 'built-entries.json');
+            const hasBuiltEntriesCache = await _promises.default.access(this.builtEntriesCachePath).then(()=>true, ()=>false);
+            if (hasBuiltEntriesCache) {
+                try {
+                    const builtEntries = JSON.parse(await _promises.default.readFile(this.builtEntriesCachePath, 'utf-8') || '{}');
+                    await Promise.all(Object.keys(builtEntries).map(async (entryKey)=>{
+                        const entryData = builtEntries[entryKey];
+                        const isEntry = entryData.type === _ondemandentryhandler.EntryTypes.ENTRY;
+                        const isChildEntry = entryData.type === _ondemandentryhandler.EntryTypes.CHILD_ENTRY;
+                        // Check if the page was removed or disposed and remove it
+                        if (isEntry) {
+                            const pageExists = !entryData.dispose && await _promises.default.access(entryData.absolutePagePath).then(()=>true, ()=>false);
+                            if (!pageExists) {
+                                delete builtEntries[entryKey];
+                                return;
+                            } else if (!('hash' in builtEntries[entryKey]) || builtEntries[entryKey].hash !== await calculateFileHash(entryData.absolutePagePath)) {
+                                delete builtEntries[entryKey];
+                                return;
+                            }
+                        }
+                        // For child entries, if it has an entry file and it's gone, remove it
+                        if (isChildEntry) {
+                            if (entryData.absoluteEntryFilePath) {
+                                const pageExists = !entryData.dispose && await _promises.default.access(entryData.absoluteEntryFilePath).then(()=>true, ()=>false);
+                                if (!pageExists) {
+                                    delete builtEntries[entryKey];
+                                    return;
+                                } else {
+                                    if (!('hash' in builtEntries[entryKey]) || builtEntries[entryKey].hash !== await calculateFileHash(entryData.absoluteEntryFilePath)) {
+                                        delete builtEntries[entryKey];
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    }));
+                    Object.assign((0, _ondemandentryhandler.getEntries)(multiCompiler.outputPath), builtEntries);
+                } catch (error) {
+                    console.error('Rspack failed to read built entries cache: ', error);
+                }
+            }
+        });
+    }
+    async ensurePage({ page, clientOnly, appPaths, definition, isApp, url }) {
+        await super.ensurePage({
+            page,
+            clientOnly,
+            appPaths,
+            definition,
+            isApp,
+            url
+        });
+        const entries = (0, _ondemandentryhandler.getEntries)(this.multiCompiler.outputPath);
+        const builtEntries = {};
+        await Promise.all(Object.keys(entries).map(async (entryName)=>{
+            const entry = entries[entryName];
+            if (entry.status !== _ondemandentryhandler.BUILT) return;
+            const result = /^(client|server|edge-server)@(app|pages|root)@(.*)/g.exec(entryName);
+            const [, key /* pageType */ , , ] = result// this match should always happen
+            ;
+            if (key === 'client' && !this.isClientCacheEnabled) return;
+            if (key === 'server' && !this.isServerCacheEnabled) return;
+            if (key === 'edge-server' && !this.isEdgeServerCacheEnabled) return;
+            // TODO: Rspack does not store middleware entries in persistent cache, causing
+            // test/integration/middleware-src/test/index.test.ts to fail. This is a temporary
+            // workaround to skip middleware entry caching until Rspack properly supports it.
+            if (page === '/middleware') {
+                return;
+            }
+            let hash;
+            if (entry.type === _ondemandentryhandler.EntryTypes.ENTRY) {
+                hash = await calculateFileHash(entry.absolutePagePath);
+            } else if (entry.absoluteEntryFilePath) {
+                hash = await calculateFileHash(entry.absoluteEntryFilePath);
+            }
+            if (!hash) {
+                return;
+            }
+            builtEntries[entryName] = entry;
+            builtEntries[entryName].hash = hash;
+        }));
+        const hasBuitEntriesCache = await _promises.default.access(this.builtEntriesCachePath).then(()=>true, ()=>false);
+        try {
+            if (!hasBuitEntriesCache) {
+                await _promises.default.mkdir(_path.default.dirname(this.builtEntriesCachePath), {
+                    recursive: true
+                });
+            }
+            await _promises.default.writeFile(this.builtEntriesCachePath, JSON.stringify(builtEntries, null, 2));
+        } catch (error) {
+            console.error('Rspack failed to write built entries cache: ', error);
+        }
+    }
+    constructor(...args){
+        super(...args), this.isClientCacheEnabled = false, this.isServerCacheEnabled = false, this.isEdgeServerCacheEnabled = false;
+    }
+}
+async function calculateFileHash(filePath, algorithm = 'sha256') {
+    if (!await _promises.default.access(filePath).then(()=>true, ()=>false)) {
+        return;
+    }
+    const fileBuffer = await _promises.default.readFile(filePath);
+    const hash = (0, _crypto.createHash)(algorithm);
+    hash.update(fileBuffer);
+    return hash.digest('hex');
+}
+
+//# sourceMappingURL=hot-reloader-rspack.js.map

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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "createHotReloaderTurbopack", {
     }
 });
 const _promises = require("fs/promises");
+const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
 const _path = require("path");
 const _url = require("url");
 const _ws = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ws"));
@@ -33,20 +34,20 @@ const _messages = require("./messages");
 const _encryptionutilsserver = require("../app-render/encryption-utils-server");
 const _apppageroutedefinition = require("../route-definitions/app-page-route-definition");
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
-const _utils2 = require("../lib/utils");
 const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
 const _patcherrorinspect = require("../patch-error-inspect");
 const _getnexterrorfeedbackmiddleware = require("../../next-devtools/server/get-next-error-feedback-middleware");
-const _utils3 = require("../../shared/lib/turbopack/utils");
+const _utils2 = require("../../shared/lib/turbopack/utils");
 const _getdevoverlayfontmiddleware = require("../../next-devtools/server/font/get-dev-overlay-font-middleware");
 const _devindicatorserverstate = require("./dev-indicator-server-state");
 const _devindicatormiddleware = require("../../next-devtools/server/dev-indicator-middleware");
 const _restartdevservermiddleware = require("../../next-devtools/server/restart-dev-server-middleware");
 const _compilationevents = require("../../shared/lib/turbopack/compilation-events");
-const _utils4 = require("../../build/utils");
+const _utils3 = require("../../build/utils");
 const _receivelogs = require("./browser-logs/receive-logs");
 const _normalizepath = require("../../lib/normalize-path");
 const _devtoolsconfigmiddleware = require("../../next-devtools/server/devtools-config-middleware");
+const _attachnodejsdebuggermiddleware = require("../../next-devtools/server/attach-nodejs-debugger-middleware");
 const _debugchannel = require("./debug-channel");
 const _hotreloadersharedutils = require("./hot-reloader-shared-utils");
 const _getmcpmiddleware = require("../mcp/get-mcp-middleware");
@@ -55,6 +56,7 @@ const _getpagemetadata = require("../mcp/tools/get-page-metadata");
 const _formaterrors = require("../mcp/tools/utils/format-errors");
 const _mcptelemetrytracker = require("../mcp/mcp-telemetry-tracker");
 const _filelogger = require("./browser-logs/file-logger");
+const _serializederrors = require("./serialized-errors");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -151,7 +153,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-        version: "16.0.10"
+        version: "16.1.1"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -170,7 +172,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     if (nextConfig.experimental.clientRouterFilter) {
     // TODO this need to be set correctly for filesystem cache to work
     }
-    const supportedBrowsers = (0, _utils4.getSupportedBrowsers)(projectPath, dev);
+    const supportedBrowsers = (0, _utils3.getSupportedBrowsers)(projectPath, dev);
     const currentNodeJsVersion = process.versions.node;
     const rootPath = ((_opts_nextConfig_turbopack = opts.nextConfig.turbopack) == null ? void 0 : _opts_nextConfig_turbopack.root) || opts.nextConfig.outputFileTracingRoot || projectPath;
     const project = await bindings.turbo.createProject({
@@ -202,9 +204,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         previewProps: opts.fsChecker.prerenderManifest.preview,
         browserslistQuery: supportedBrowsers.join(', '),
         noMangling: false,
+        writeRoutesHashesManifest: false,
         currentNodeJsVersion
     }, {
-        persistentCaching: (0, _utils3.isFileSystemCacheEnabledForDev)(opts.nextConfig),
+        persistentCaching: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
         memoryLimit: (_opts_nextConfig_experimental = opts.nextConfig.experimental) == null ? void 0 : _opts_nextConfig_experimental.turbopackMemoryLimit,
         isShortSession: false
     });
@@ -409,7 +412,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         try {
             const changed = await changedPromise;
             for await (const change of changed){
-                (0, _utils3.processIssues)(currentEntryIssues, key, change, false, true);
+                (0, _utils2.processIssues)(currentEntryIssues, key, change, false, true);
                 // TODO: Get an actual content hash from Turbopack.
                 const message = await createMessage(change, String(++hmrHash));
                 if (message) {
@@ -451,7 +454,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         try {
             await subscription.next();
             for await (const data of subscription){
-                (0, _utils3.processIssues)(state.clientIssues, key, data, false, true);
+                (0, _utils2.processIssues)(state.clientIssues, key, data, false, true);
                 if (data.type !== 'issues') {
                     sendTurbopackMessage(data);
                 }
@@ -490,7 +493,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             (0, _turbopackutils.processTopLevelIssues)(currentTopLevelIssues, entrypoints);
             // Certain crtical issues prevent any entrypoints from being constructed so return early
             if (!('routes' in entrypoints)) {
-                (0, _utils4.printBuildErrors)(entrypoints, true);
+                (0, _utils3.printBuildErrors)(entrypoints, true);
                 currentEntriesHandlingResolve();
                 currentEntriesHandlingResolve = undefined;
                 continue;
@@ -603,6 +606,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 });
             }
         }),
+        (0, _attachnodejsdebuggermiddleware.getAttachNodejsDebuggerMiddleware)(),
         ...nextConfig.experimental.mcpServer ? [
             (0, _getmcpmiddleware.getMcpMiddleware)({
                 projectPath,
@@ -638,14 +642,12 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         return versionInfoCached;
     };
     let devtoolsFrontendUrl;
-    const nodeOptions = (0, _utils2.getParsedNodeOptions)();
-    const nodeDebugType = (0, _utils2.getNodeDebugType)(nodeOptions);
-    if (nodeDebugType) {
-        const debugPort = process.debugPort;
+    const inspectorURLRaw = _inspector.url();
+    if (inspectorURLRaw !== undefined) {
+        const inspectorURL = new URL(inspectorURLRaw);
         let debugInfo;
         try {
-            // It requires to use 127.0.0.1 instead of localhost for server-side fetching.
-            const debugInfoList = await fetch(`http://127.0.0.1:${debugPort}/json/list`).then((res)=>res.json());
+            const debugInfoList = await fetch(`http://${inspectorURL.host}/json/list`).then((res)=>res.json());
             debugInfo = debugInfoList[0];
         } catch  {}
         if (debugInfo) {
@@ -720,6 +722,8 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             isLegacyClient: true
                         });
                     }
+                    (0, _debugchannel.connectReactDebugChannelForHtmlRequest)(htmlRequestId, sendToClient.bind(null, client));
+                    (0, _serializederrors.sendSerializedErrorsToClientForHtmlRequest)(htmlRequestId, sendToClient.bind(null, client));
                 } else {
                     clientsWithoutHtmlRequestId.add(client);
                     onUpgrade(client, {
@@ -854,7 +858,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     for (const issue of entryIssues.values()){
                         if (issue.severity !== 'warning') {
                             errors.push({
-                                message: (0, _utils3.formatIssue)(issue)
+                                message: (0, _utils2.formatIssue)(issue)
                             });
                         } else {
                             (0, _turbopackutils.printNonFatalIssue)(issue);
@@ -881,9 +885,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         devToolsConfig
                     };
                     sendToClient(client, syncMessage);
-                    if (htmlRequestId) {
-                        (0, _debugchannel.connectReactDebugChannelForHtmlRequest)(htmlRequestId, sendToClient.bind(null, client));
-                    }
                 })();
             });
         },
@@ -946,6 +947,17 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 (0, _debugchannel.connectReactDebugChannel)(requestId, debugChannel, sendToClient.bind(null, client));
             }
         },
+        sendErrorsToBrowser (errorsRscStream, htmlRequestId) {
+            const client = clientsByHtmlRequestId.get(htmlRequestId);
+            if (client) {
+                // If the client is connected, we can send the errors immediately.
+                (0, _serializederrors.sendSerializedErrorsToClient)(errorsRscStream, sendToClient.bind(null, client));
+            } else {
+                // Otherwise, store the errors stream so that we can send it when the
+                // client connects.
+                (0, _serializederrors.setErrorsRscStreamForHtmlRequest)(htmlRequestId, errorsRscStream);
+            }
+        },
         setHmrServerError (_error) {
         // Not implemented yet.
         },
@@ -964,11 +976,11 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     ...topLevelIssues,
                     ...thisEntryIssues.values()
                 ].map((issue)=>{
-                    const formattedIssue = (0, _utils3.formatIssue)(issue);
+                    const formattedIssue = (0, _utils2.formatIssue)(issue);
                     if (issue.severity === 'warning') {
                         (0, _turbopackutils.printNonFatalIssue)(issue);
                         return null;
-                    } else if ((0, _utils3.isWellKnownError)(issue)) {
+                    } else if ((0, _utils2.isWellKnownError)(issue)) {
                         _log.error(formattedIssue);
                     }
                     return Object.defineProperty(new Error(formattedIssue), "__NEXT_ERROR_CODE", {
@@ -982,7 +994,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             const errors = [];
             for (const issue of topLevelIssues){
                 if (issue.severity !== 'warning') {
-                    errors.push(Object.defineProperty(new Error((0, _utils3.formatIssue)(issue)), "__NEXT_ERROR_CODE", {
+                    errors.push(Object.defineProperty(new Error((0, _utils2.formatIssue)(issue)), "__NEXT_ERROR_CODE", {
                         value: "E394",
                         enumerable: false,
                         configurable: true
@@ -992,7 +1004,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             for (const entryIssues of currentEntryIssues.values()){
                 for (const issue of entryIssues.values()){
                     if (issue.severity !== 'warning') {
-                        const message = (0, _utils3.formatIssue)(issue);
+                        const message = (0, _utils2.formatIssue)(issue);
                         errors.push(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
                             value: "E394",
                             enumerable: false,
@@ -1179,10 +1191,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             for (const [key, issue] of issueMap){
                                 if (issue.severity === 'warning') continue;
                                 if (errorsMap.has(key)) continue;
-                                const message = (0, _utils3.formatIssue)(issue);
+                                const message = (0, _utils2.formatIssue)(issue);
                                 errorsMap.set(key, {
                                     message,
-                                    details: issue.detail ? (0, _utils3.renderStyledStringToErrorAnsi)(issue.detail) : undefined
+                                    details: issue.detail ? (0, _utils2.renderStyledStringToErrorAnsi)(issue.detail) : undefined
                                 });
                             }
                         }

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

@@ -44,6 +44,7 @@ var HMR_MESSAGE_SENT_TO_BROWSER = /*#__PURE__*/ function(HMR_MESSAGE_SENT_TO_BRO
     HMR_MESSAGE_SENT_TO_BROWSER["REQUEST_PAGE_METADATA"] = "requestPageMetadata";
     // Binary messages:
     HMR_MESSAGE_SENT_TO_BROWSER[HMR_MESSAGE_SENT_TO_BROWSER["REACT_DEBUG_CHUNK"] = 0] = "REACT_DEBUG_CHUNK";
+    HMR_MESSAGE_SENT_TO_BROWSER[HMR_MESSAGE_SENT_TO_BROWSER["ERRORS_TO_SHOW_IN_BROWSER"] = 1] = "ERRORS_TO_SHOW_IN_BROWSER";
     return HMR_MESSAGE_SENT_TO_BROWSER;
 }({});
 var HMR_MESSAGE_SENT_TO_SERVER = /*#__PURE__*/ function(HMR_MESSAGE_SENT_TO_SERVER) {

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

@@ -23,6 +23,7 @@ _export(exports, {
 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 _path = require("path");
 const _entries = require("../../build/entries");
 const _getstaticinfoincludinglayouts = require("../../build/get-static-info-including-layouts");
@@ -50,7 +51,6 @@ const _routekind = require("../route-kind");
 const _hotreloadertypes = require("./hot-reloader-types");
 const _pagetypes = require("../../lib/page-types");
 const _messages = require("./messages");
-const _utils2 = require("../lib/utils");
 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");
@@ -59,6 +59,7 @@ const _restartdevservermiddleware = require("../../next-devtools/server/restart-
 const _cacheinvalidation = require("../../build/webpack/cache-invalidation");
 const _receivelogs = require("./browser-logs/receive-logs");
 const _devtoolsconfigmiddleware = require("../../next-devtools/server/devtools-config-middleware");
+const _attachnodejsdebuggermiddleware = require("../../next-devtools/server/attach-nodejs-debugger-middleware");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _debugchannel = require("./debug-channel");
 const _hotreloadersharedutils = require("./hot-reloader-shared-utils");
@@ -66,6 +67,7 @@ const _getmcpmiddleware = require("../mcp/get-mcp-middleware");
 const _formaterrors = require("../mcp/tools/utils/format-errors");
 const _mcptelemetrytracker = require("../mcp/mcp-telemetry-tracker");
 const _filelogger = require("./browser-logs/file-logger");
+const _serializederrors = require("./serialized-errors");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -231,7 +233,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "16.0.10"
+            version: "16.1.1"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.
@@ -502,6 +504,7 @@ class HotReloaderWebpack {
             });
             if (htmlRequestId) {
                 (0, _debugchannel.connectReactDebugChannelForHtmlRequest)(htmlRequestId, this.sendToClient.bind(this, client));
+                (0, _serializederrors.sendSerializedErrorsToClientForHtmlRequest)(htmlRequestId, this.sendToClient.bind(this, client));
                 if (enableCacheComponents) {
                     const status = this.cacheStatusesByRequestId.get(htmlRequestId);
                     if (status) {
@@ -665,15 +668,12 @@ class HotReloaderWebpack {
         startSpan.stop() // Stop immediately to create an artificial parent span
         ;
         this.versionInfo = await this.tracedGetVersionInfo(startSpan);
-        const nodeOptions = (0, _utils2.getParsedNodeOptions)();
-        const nodeDebugType = (0, _utils2.getNodeDebugType)(nodeOptions);
-        if (nodeDebugType && !this.devtoolsFrontendUrl) {
-            const debugPort = process.debugPort;
+        const inspectorURLRaw = _inspector.url();
+        if (inspectorURLRaw !== undefined) {
+            const inspectorURL = new URL(inspectorURLRaw);
             let debugInfo;
             try {
-                // It requires to use 127.0.0.1 instead of localhost for server-side fetching.
-                const debugInfoList = await fetch(`http://127.0.0.1:${debugPort}/json/list`).then((res)=>res.json());
-                // There will be only one item for current process, so always get the first item.
+                const debugInfoList = await fetch(`http://${inspectorURL.host}/json/list`).then((res)=>res.json());
                 debugInfo = debugInfoList[0];
             } catch  {}
             if (debugInfo) {
@@ -947,6 +947,7 @@ class HotReloaderWebpack {
         this.activeWebpackConfigs.parallelism = 1;
         await Promise.all(Array.from((0, _webpackconfig.getCacheDirectories)(this.activeWebpackConfigs)).map(_cacheinvalidation.checkFileSystemCacheInvalidationAndCleanup));
         this.multiCompiler = (0, _getwebpackbundler.default)()(this.activeWebpackConfigs);
+        await this.afterCompile(this.multiCompiler);
         // Copy over the filesystem so that it is shared between all compilers.
         const inputFileSystem = this.multiCompiler.compilers[0].inputFileSystem;
         for (const compiler of this.multiCompiler.compilers){
@@ -1199,55 +1200,46 @@ class HotReloaderWebpack {
             nextConfig: this.config,
             ...this.config.onDemandEntries
         });
-        this.middlewares = [
-            (0, _middlewarewebpack.getOverlayMiddleware)({
-                rootDirectory: this.dir,
-                isSrcDir: this.isSrcDir,
-                clientStats: ()=>this.clientStats,
-                serverStats: ()=>this.serverStats,
-                edgeServerStats: ()=>this.edgeServerStats
-            }),
-            (0, _middlewarewebpack.getSourceMapMiddleware)({
-                clientStats: ()=>this.clientStats,
-                serverStats: ()=>this.serverStats,
-                edgeServerStats: ()=>this.edgeServerStats
-            }),
-            (0, _getnexterrorfeedbackmiddleware.getNextErrorFeedbackMiddleware)(this.telemetry),
-            (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)({
+        this.middlewares.push((0, _middlewarewebpack.getOverlayMiddleware)({
+            rootDirectory: this.dir,
+            isSrcDir: this.isSrcDir,
+            clientStats: ()=>this.clientStats,
+            serverStats: ()=>this.serverStats,
+            edgeServerStats: ()=>this.edgeServerStats
+        }), (0, _middlewarewebpack.getSourceMapMiddleware)({
+            clientStats: ()=>this.clientStats,
+            serverStats: ()=>this.serverStats,
+            edgeServerStats: ()=>this.edgeServerStats
+        }), (0, _getnexterrorfeedbackmiddleware.getNextErrorFeedbackMiddleware)(this.telemetry), (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)({
+            distDir: this.distDir,
+            sendUpdateSignal: (data)=>{
+                var // Update the in-memory devToolsConfig value
+                // which will be used for the next onHMR call.
+                _this_webpackHotMiddleware;
+                (_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.updateDevToolsConfig(data);
+                this.send({
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.DEVTOOLS_CONFIG,
+                    data
+                });
+            }
+        }), (0, _attachnodejsdebuggermiddleware.getAttachNodejsDebuggerMiddleware)(), ...this.config.experimental.mcpServer ? [
+            (0, _getmcpmiddleware.getMcpMiddleware)({
+                projectPath: this.dir,
                 distDir: this.distDir,
-                sendUpdateSignal: (data)=>{
-                    var // Update the in-memory devToolsConfig value
-                    // which will be used for the next onHMR call.
-                    _this_webpackHotMiddleware;
-                    (_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.updateDevToolsConfig(data);
-                    this.send({
-                        type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.DEVTOOLS_CONFIG,
-                        data
-                    });
-                }
-            }),
-            ...this.config.experimental.mcpServer ? [
-                (0, _getmcpmiddleware.getMcpMiddleware)({
-                    projectPath: this.dir,
-                    distDir: this.distDir,
-                    nextConfig: this.config,
-                    pagesDir: this.pagesDir,
-                    appDir: this.appDir,
-                    sendHmrMessage: (message)=>this.send(message),
-                    getActiveConnectionCount: ()=>{
-                        var _this_webpackHotMiddleware;
-                        return ((_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.getClientCount()) ?? 0;
-                    },
-                    getDevServerUrl: ()=>process.env.__NEXT_PRIVATE_ORIGIN
-                })
-            ] : []
-        ];
+                nextConfig: this.config,
+                pagesDir: this.pagesDir,
+                appDir: this.appDir,
+                sendHmrMessage: (message)=>this.send(message),
+                getActiveConnectionCount: ()=>{
+                    var _this_webpackHotMiddleware;
+                    return ((_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.getClientCount()) ?? 0;
+                },
+                getDevServerUrl: ()=>process.env.__NEXT_PRIVATE_ORIGIN
+            })
+        ] : []);
         (0, _formaterrors.setStackFrameResolver)(async (request)=>{
             return (0, _middlewarewebpack.getOriginalStackFrames)({
                 isServer: request.isServer,
@@ -1261,6 +1253,7 @@ class HotReloaderWebpack {
             });
         });
     }
+    async afterCompile(_multiCompiler) {}
     invalidate({ reloadAfterInvalidation } = {
         reloadAfterInvalidation: false
     }) {
@@ -1344,6 +1337,18 @@ class HotReloaderWebpack {
             (0, _debugchannel.connectReactDebugChannel)(requestId, debugChannel, this.sendToClient.bind(this, client));
         }
     }
+    sendErrorsToBrowser(errorsRscStream, htmlRequestId) {
+        var _this_webpackHotMiddleware;
+        const client = (_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.getClient(htmlRequestId);
+        if (client) {
+            // If the client is connected, we can send the errors immediately.
+            (0, _serializederrors.sendSerializedErrorsToClient)(errorsRscStream, this.sendToClient.bind(this, client));
+        } else {
+            // Otherwise, store the errors stream so that we can send it when the
+            // client connects.
+            (0, _serializederrors.setErrorsRscStreamForHtmlRequest)(htmlRequestId, errorsRscStream);
+        }
+    }
     async ensurePage({ page, clientOnly, appPaths, definition, isApp, url }) {
         return this.hotReloaderSpan.traceChild('ensure-page', {
             inputPage: page

package/standalone/node_modules/next/dist/server/dev/log-requests.js

@@ -39,9 +39,9 @@ function ignoreLoggingIncomingRequests(request, loggingConfig) {
     // If array of RegExp, ignore if any pattern matches
     return ignore.some((pattern)=>pattern.test(request.url));
 }
-function logRequests(request, response, loggingConfig, requestStartTime, requestEndTime, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd) {
+function logRequests(request, response, loggingConfig, requestStartTime, requestEndTime, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration) {
     if (!ignoreLoggingIncomingRequests(request, loggingConfig)) {
-        logIncomingRequests(request, requestStartTime, requestEndTime, response.statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd);
+        logIncomingRequests(request, requestStartTime, requestEndTime, response.statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration);
     }
     if (request.fetchMetrics) {
         for (const fetchMetric of request.fetchMetrics){
@@ -49,7 +49,7 @@ function logRequests(request, response, loggingConfig, requestStartTime, request
         }
     }
 }
-function logIncomingRequests(request, requestStartTime, requestEndTime, statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd) {
+function logIncomingRequests(request, requestStartTime, requestEndTime, statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration) {
     const isRSC = (0, _requestmeta.getRequestMeta)(request, 'isRSCRequest');
     const url = isRSC ? (0, _url.stripNextRscUnionQuery)(request.url) : request.url;
     const statusCodeColor = statusCode < 200 ? _picocolors.white : statusCode < 300 ? _picocolors.green : statusCode < 400 ? _picocolors.blue : statusCode < 500 ? _picocolors.yellow : _picocolors.red;
@@ -74,6 +74,14 @@ function logIncomingRequests(request, requestStartTime, requestEndTime, statusCo
             'compile',
             frameworkTime
         ]);
+        // Insert after compile, before render based on the execution order.
+        if (devGenerateStaticParamsDuration) {
+            // Pages Router getStaticPaths are technically "generate params" as well.
+            times.push([
+                'generate-params',
+                devGenerateStaticParamsDuration
+            ]);
+        }
         times.push([
             'render',
             requestEndTime - devRequestTimingInternalsEnd

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

@@ -26,6 +26,16 @@ const FAST_REFRESH_RUNTIME_RELOAD = 'Fast Refresh had to perform a full reload d
 const textEncoder = new TextEncoder();
 function createBinaryHmrMessageData(message) {
     switch(message.type){
+        case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ERRORS_TO_SHOW_IN_BROWSER:
+            {
+                const { serializedErrors } = message;
+                const totalLength = 1 + serializedErrors.length;
+                const data = new Uint8Array(totalLength);
+                const view = new DataView(data.buffer);
+                view.setUint8(0, _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ERRORS_TO_SHOW_IN_BROWSER);
+                data.set(serializedErrors, 1);
+                return data;
+            }
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK:
             {
                 const { requestId, chunk } = message;