@aeolus-fleet/console 0.34.0 → 0.36.0

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

@@ -16,6 +16,7 @@ const _url = require("url");
 const _ws = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ws"));
 const _store = require("../../build/output/store");
 const _hotreloadertypes = require("./hot-reloader-types");
+const _recursivedelete = require("../../lib/recursive-delete");
 const _swc = require("../../build/swc");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
 const _constants = require("../../shared/lib/constants");
@@ -23,6 +24,8 @@ const _middlewareturbopack = require("./middleware-turbopack");
 const _utils = require("../../shared/lib/utils");
 const _utils1 = require("../utils");
 const _loadmanifestexternal = require("../load-manifest.external");
+const _loadcomponents = require("../load-components");
+const _manifestssingleton = require("../app-render/manifests-singleton");
 const _requirecache = require("./require-cache");
 const _devvalidationworkerpool = require("./dev-validation-worker-pool");
 const _renderserver = require("../lib/render-server");
@@ -41,7 +44,6 @@ const _entries = require("../../build/entries");
 const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
 const _patcherrorinspect = require("../patch-error-inspect");
 const _sourcemaps = require("../lib/source-maps");
-const _getnexterrorfeedbackmiddleware = require("../../next-devtools/server/get-next-error-feedback-middleware");
 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");
@@ -51,6 +53,7 @@ const _compilationevents = require("../../shared/lib/turbopack/compilation-event
 const _deferredemit = require("../../shared/lib/turbopack/deferred-emit");
 const _getsupportedbrowsers = require("../../build/get-supported-browsers");
 const _printbuilderrors = require("../../build/print-build-errors");
+const _strictroutematchingconfig = require("../lib/router-utils/strict-route-matching-config");
 const _receivelogs = require("./browser-logs/receive-logs");
 const _normalizepath = require("../../lib/normalize-path");
 const _turbopackcacheseed = require("../../lib/turbopack-cache-seed");
@@ -65,6 +68,7 @@ const _resolvepathtoroute = require("../mcp/tools/utils/resolve-path-to-route");
 const _geterrors = require("../mcp/tools/get-errors");
 const _getpagemetadata = require("../mcp/tools/get-page-metadata");
 const _formaterrors = require("../mcp/tools/utils/format-errors");
+const _runtimeerrorstate = require("./runtime-error-state");
 const _mcptelemetrytracker = require("../mcp/mcp-telemetry-tracker");
 const _filelogger = require("./browser-logs/file-logger");
 const _serializederrors = require("./serialized-errors");
@@ -120,6 +124,24 @@ const wsServer = new _ws.default.Server({
 const isTestMode = !!(process.env.NEXT_TEST_MODE || process.env.__NEXT_TEST_MODE || process.env.DEBUG);
 const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
 /** Output directory (relative to `distDir`) of server-HMR-managed chunks. */ const SERVER_HMR_CHUNKS_DIR = (0, _path.join)('server', 'chunks');
+const TURBOPACK_OUTPUT_DIRS = [
+    (0, _path.join)('static', 'chunks'),
+    (0, _path.join)('static', 'media'),
+    (0, _path.join)('static', 'service-worker'),
+    (0, _path.join)('server', 'app'),
+    (0, _path.join)('server', 'pages'),
+    SERVER_HMR_CHUNKS_DIR,
+    (0, _path.join)('server', 'assets'),
+    (0, _path.join)('server', 'edge', 'chunks'),
+    (0, _path.join)('server', 'edge', 'assets'),
+    (0, _path.join)('server', 'middleware'),
+    (0, _path.join)('server', 'instrumentation')
+];
+const RETAINED_OUTPUT_PATHS = new Set([
+    'cache',
+    'lock',
+    ...TURBOPACK_OUTPUT_DIRS
+]);
 /**
  * Collects the output chunk paths touched by a partial HMR update. Both
  * single-chunk `EcmascriptMergedUpdate`s and `ChunkListUpdate`s (which nest
@@ -141,97 +163,96 @@ const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
             }
         }
     } else {
-        throw Object.defineProperty(new Error(`[Server HMR] unreachable: unknown HMR instruction type ${instruction.type}`), "__NEXT_ERROR_CODE", {
-            value: "E1459",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`[Server HMR] unreachable: unknown HMR instruction type ${instruction.type}`);
     }
     return Array.from(paths);
 }
 function setupServerHmr(project, { reEvaluateAllModulesExpensive, onApplied }) {
-    async function runSubscription() {
-        const subscription = project.allHmrEvents(_swc.HmrTarget.Server);
-        // Subscribing immediately emits one event describing the current state.
-        // There's no previous state to diff it against, so it never carries anything
-        // to apply. Drop it; real updates start with the second event.
-        await subscription.next();
-        for await (const result of subscription){
-            const update = result;
-            // A 'restart' from the wire protocol means the update can't be applied
-            // incrementally, so we must fully re-evaluate all chunks from disk. This
-            // clears the module cache and notifies browsers to refetch RSC.
-            const requiresFullReEvaluation = update.type === 'restart';
-            if (requiresFullReEvaluation) {
-                await reEvaluateAllModulesExpensive();
-                continue;
-            }
-            if (update.type !== 'partial') {
-                continue;
-            }
-            // `EcmascriptMergedUpdate` is the only instruction the Node.js runtime
-            // knows how to apply; `ChunkListUpdate` is browser-only. Anything else is
-            // unknown to us, so ignore it rather than evicting the module cache.
-            const instruction = update.instruction;
-            if (!instruction || instruction.type !== 'EcmascriptMergedUpdate' && instruction.type !== 'ChunkListUpdate') {
-                throw Object.defineProperty(new Error(`[Server HMR] unreachable: unexpected update instruction type ${instruction.type}`), "__NEXT_ERROR_CODE", {
-                    value: "E1460",
-                    enumerable: false,
-                    configurable: true
-                });
-            }
-            // No handler registered yet (before first request, or right after
-            // reEvaluateAllModulesExpensive()) — nothing live to update, so skip
-            // until the next request.
-            const handlers = globalThis.__turbopack_server_hmr_handlers__;
-            if (!handlers || handlers.size === 0) {
-                continue;
+    let pending = Promise.resolve();
+    // Each pull snapshots only the requested endpoint's entries. Keep independent
+    // baselines so building one route does not discard another route's version.
+    const versions = new Map();
+    let needsReEvaluation = false;
+    async function recover() {
+        try {
+            await reEvaluateAllModulesExpensive();
+            versions.clear();
+            needsReEvaluation = false;
+        } catch (error) {
+            console.error('[Server HMR] Re-evaluating modules failed:', error);
+        }
+    }
+    function apply(entryPaths) {
+        const applyPromise = pending.then(async ()=>{
+            if (needsReEvaluation) {
+                await recover();
+                return;
             }
-            if (typeof __turbopack_server_hmr_apply__ === 'function') {
-                try {
-                    __turbopack_server_hmr_apply__(update);
-                    // The validation worker keeps its own copy of the module graph, and
-                    // applies the same update to it.
-                    (0, _devvalidationworkerpool.mirrorModuleStateToDevValidationWorker)({
-                        type: 'apply',
-                        update
-                    });
-                } catch  {
-                    // A matching runtime tried the apply and threw. Evict require.cache
-                    // so the next request loads fresh, then skip onApplied. (A no-match
-                    // update is a no-op and does not throw.)
-                    await reEvaluateAllModulesExpensive();
-                    continue;
+            try {
+                const versionKey = [
+                    ...entryPaths
+                ].sort().join('\0');
+                // `issues` is intentionally dropped: this pull scans project-wide chunk
+                // lists, so its issues may belong to an unrelated or removed route, and
+                // endpoint writes already report route-scoped issues.
+                const { value: update } = await project.getServerHmrUpdate(versions.get(versionKey), entryPaths);
+                if (update.version) {
+                    versions.set(versionKey, update.version);
                 }
-                const updatedChunkPaths = collectUpdatedChunkPaths(instruction);
-                // An empty partial only advances the version state (e.g. the seed
-                // transition or a new endpoint); nothing changed on disk, so don't
-                // invalidate manifests or ping browsers to refetch RSC.
-                if (updatedChunkPaths.length > 0) {
-                    await onApplied(updatedChunkPaths);
+                switch(update.kind){
+                    case 'none':
+                        return;
+                    case 'partial':
+                        {
+                            const handlers = globalThis.__turbopack_server_hmr_handlers__;
+                            if (!handlers || handlers.size === 0) return;
+                            const payload = {
+                                type: 'partial',
+                                instruction: update.instruction
+                            };
+                            if (typeof __turbopack_server_hmr_apply__ === 'function') {
+                                try {
+                                    __turbopack_server_hmr_apply__(payload);
+                                    (0, _devvalidationworkerpool.mirrorModuleStateToDevValidationWorker)({
+                                        type: 'apply',
+                                        update: payload
+                                    });
+                                    const updatedChunkPaths = collectUpdatedChunkPaths(update.instruction);
+                                    if (updatedChunkPaths.length > 0) {
+                                        await onApplied(updatedChunkPaths);
+                                    }
+                                    return;
+                                } catch  {}
+                            }
+                            break;
+                        }
+                    case 'restart':
+                        break;
+                    default:
+                        throw new Error(`Unknown server HMR update kind: ${update.kind}`);
                 }
-            } else {
-                await reEvaluateAllModulesExpensive();
+            } catch (error) {
+                console.error('[Server HMR] Update failed, re-evaluating modules:', error);
             }
-        }
+            needsReEvaluation = true;
+            await recover();
+        });
+        pending = applyPromise;
+        return applyPromise;
     }
-    // Start listening for changes in background. Re-subscribe on error so
-    // server Fast Refresh continues working for the rest of the dev session.
-    // The delay keeps a persistently-failing subscription (which throws on the
-    // initial read) from hot-looping through reEvaluateAllModulesExpensive().
-    ;
-    (async ()=>{
-        for(;;){
-            try {
-                await runSubscription();
-                return;
-            } catch (err) {
-                console.error('[Server HMR] Subscription error, resubscribing:', err);
-                await reEvaluateAllModulesExpensive();
-                await new Promise((resolve)=>setTimeout(resolve, 1000));
-            }
-        }
-    })();
+    function reset() {
+        const resetState = ()=>{
+            versions.clear();
+            needsReEvaluation = false;
+        };
+        const resetPromise = pending.then(resetState, resetState);
+        pending = resetPromise;
+        return resetPromise;
+    }
+    return {
+        apply,
+        reset
+    };
 }
 function getSourceMapFromTurbopack(project, sourceURL) {
     let sourceMapJson = null;
@@ -281,16 +302,18 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     const dev = true;
     const buildId = 'development';
     const { nextConfig, dir: projectPath } = opts;
+    const lazyDynamicImports = nextConfig.experimental.turbopackLazyDynamicImports;
+    const lazyDynamicImportsSSR = nextConfig.experimental.turbopackLazyDynamicImportsSSR;
     const bindings = (0, _swc.getBindingsSync)();
     // Turbopack requires native bindings and cannot run with WASM bindings.
     // Detect this early and give a clear, actionable error message.
     if (bindings.isWasm) {
-        throw Object.defineProperty(new Error(`Turbopack is not supported on this platform (${process.platform}/${process.arch}) because native bindings are not available. ` + `Only WebAssembly (WASM) bindings were loaded, and Turbopack requires native bindings.\n\n` + `To use Next.js on this platform, use Webpack instead:\n` + `  next dev --webpack\n\n` + `For more information, see: https://nextjs.org/docs/app/api-reference/turbopack#supported-platforms`), "__NEXT_ERROR_CODE", {
-            value: "E1049",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Turbopack is not supported on this platform (${process.platform}/${process.arch}) because native bindings are not available. ` + `Only WebAssembly (WASM) bindings were loaded, and Turbopack requires native bindings.\n\n` + `To use Next.js on this platform, use Webpack instead:\n` + `  next dev --webpack\n\n` + `For more information, see: https://nextjs.org/docs/app/api-reference/turbopack#supported-platforms`);
     }
+    // This must finish before Turbopack records any writes. Once turbo-tasks has
+    // recorded a write effect, it dedups by hash without checking the file.
+    await (0, _recursivedelete.recursiveDeleteSyncWithAsyncRetries)(distDir, RETAINED_OUTPUT_PATHS);
+    await Promise.all(TURBOPACK_OUTPUT_DIRS.map((subDir)=>(0, _recursivedelete.recursiveDeleteSyncWithAsyncRetries)((0, _path.join)(distDir, subDir), undefined, nextConfig.experimental.turbopackStaleOutputMaxAge)));
     // For the debugging purpose, check if createNext or equivalent next instance setup in test cases
     // works correctly. Normally `run-test` hides output so only will be visible when `--debug` flag is used.
     if (isTestMode) {
@@ -302,7 +325,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.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.
@@ -330,7 +353,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             distDir
         });
     }
-    const project = await bindings.turbo.createProject({
+    const projectResult = await bindings.turbo.createProject({
         rootPath,
         projectPath: (0, _normalizepath.normalizePath)((0, _path.relative)(rootPath, projectPath) || '.'),
         distDir,
@@ -362,18 +385,25 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
-        nextVersion: "16.3.8",
+        nextVersion: "16.4.2",
         serverHmr: serverFastRefresh
     }, {
         turbopackMemoryEviction: opts.nextConfig.experimental.turbopackMemoryEvictionMode,
+        gc: opts.nextConfig.experimental.turbopackGcOptions,
         isShortSession: false
     });
+    for (const issue of projectResult.issues){
+        (0, _turbopackutils.printNonFatalIssue)(issue);
+    }
+    const project = projectResult.value;
     (0, _compilationevents.backgroundLogCompilationEvents)(project, {
         eventTypes: [
             'StartupCacheInvalidationEvent',
             'TimingEvent',
             'SlowFilesystemEvent',
-            'TraceEvent'
+            'FilesystemSettlingEvent',
+            'TraceEvent',
+            'ServerHmrEntryDiffEvent'
         ],
         parentSpan: hotReloaderSpan
     });
@@ -389,9 +419,14 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     opts.onDevServerCleanup == null ? void 0 : opts.onDevServerCleanup.call(opts, async ()=>{
         (0, _patcherrorinspect.setBundlerFindSourceMapImplementation)(()=>undefined);
         (0, _sourcemaps.setBundlerFindSourceMapURLImplementation)(()=>null);
-        await project.onExit();
+        if (process.env.__NEXT_DEV_WAIT_FOR_TURBOPACK_SHUTDOWN === '1') {
+            await project.shutdown();
+        } else {
+            await project.onExit();
+        }
         await (lockfile == null ? void 0 : lockfile.unlock());
     });
+    // Subscription detects route additions/removals; returned endpoints stay lazy.
     const entrypointsSubscription = project.entrypointsSubscribe();
     const currentWrittenEntrypoints = new Map();
     const currentEntrypoints = {
@@ -421,6 +456,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     let currentEntriesHandlingResolve;
     let currentEntriesHandling = new Promise((resolve)=>currentEntriesHandlingResolve = resolve);
     const assetMapper = new _turbopackutils.AssetMapper();
+    const serverAssetMapper = new _turbopackutils.AssetMapper();
     // Deferred entries state management
     const deferredEntriesConfig = nextConfig.experimental.deferredEntries;
     const hasDeferredEntriesConfig = deferredEntriesConfig && deferredEntriesConfig.length > 0;
@@ -477,6 +513,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             }
         }
     }, 500);
+    // Server HMR supports App Router entries on the Node.js runtime.
+    function participatesInServerHmr(key, writtenEndpoint) {
+        return !!serverFastRefresh && (0, _entrykey.splitEntryKey)(key).type === 'app' && writtenEndpoint.type !== 'edge';
+    }
     function clearRequireCache(key, writtenEndpoint, { force } = {}) {
         if (force) {
             for (const { path, contentHash } of writtenEndpoint.serverPaths){
@@ -526,11 +566,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             void (0, _renderserver.clearAllModuleContexts)();
         }
         const serverPaths = writtenEndpoint.serverPaths.map(({ path: p })=>(0, _path.join)(distDir, p));
-        const { type: entryType } = (0, _entrykey.splitEntryKey)(key);
-        // Server HMR applies to App Router entries built with the Turbopack Node.js
-        // runtime: app pages and route handlers (including metadata routes). Edge
-        // routes, Pages Router pages, and middleware/instrumentation are excluded.
-        const usesServerHmr = serverFastRefresh && entryType === 'app' && writtenEndpoint.type !== 'edge';
+        const usesServerHmr = participatesInServerHmr(key, writtenEndpoint);
         const serverChunksPrefix = SERVER_HMR_CHUNKS_DIR + _path.sep;
         const filesToDelete = [];
         for (const file of serverPaths){
@@ -588,7 +624,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         };
     };
     let hmrEventHappened = false;
-    // A counter identifying the current version of the compiled output, included
+    // A counter identifying the current version of the server component output, included
     // by `"use cache"` in dev cache keys so that cached entries revalidate after
     // an edit. It advances once per HMR change event (for App Router pages that
     // is an RSC change, which is what a cached render depends on), independent of
@@ -596,7 +632,12 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     // messages: those are sent per connected client on every compilation, so
     // advancing there would both churn the hash without an edit and fail to
     // advance it at all when no client is connected.
-    let hmrHash = 0;
+    let serverComponentsHmrRefreshVersion = 0;
+    let clientHmrVersion = 0;
+    let clientHmrEventHappened = false;
+    // Undefined until the first entrypoints emission. That one has nothing to
+    // compare against, so every route it lists would look added.
+    let previousRouteKeys;
     // HACK: Defer sending `building` messages. Turbopack emits a compile pass for every
     // foreground-job cycle, including empty no-op recompiles scheduled by
     // request/render activity that changed no files. This allows us to prevent
@@ -604,15 +645,37 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     const pendingBuilding = new _deferredemit.DeferredEmit();
     const clientsWithoutHtmlRequestId = new Set();
     const clientsByHtmlRequestId = new Map();
+    const runtimeErrorStates = nextConfig.experimental.exposeRuntimeErrorsToHMR || Boolean(process.env.__NEXT_EXPOSE_RUNTIME_ERRORS_TO_HMR) ? new Map() : null;
     const cacheStatusesByHtmlRequestId = new Map();
     const clientStates = new WeakMap();
     function sendToClient(client, message) {
         const data = typeof message.type === 'number' ? (0, _messages.createBinaryHmrMessageData)(message) : JSON.stringify(message);
         client.send(data);
     }
+    let hasVulnerabilityInsight = false;
+    opts.hasVulnerabilityInsight.then((enabled)=>{
+        if (enabled) {
+            hasVulnerabilityInsight = true;
+            for (const client of [
+                ...clientsWithoutHtmlRequestId,
+                ...clientsByHtmlRequestId.values()
+            ]){
+                sendToClient(client, {
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.VULNERABILITY_INSIGHT,
+                    hasVulnerabilityInsight: true
+                });
+            }
+        }
+    });
     let updateInProgress = false;
     let pendingServerComponentChanges = false;
-    function sendServerComponentChanges() {
+    // Tell browsers to refetch RSC (soft refresh, not full page reload).
+    // Skip while there are outstanding compilation errors: an RSC refetch would
+    // 500 and force a full-page navigation, losing client state (e.g. recovering
+    // from a syntax error). A subsequent successful compile/apply fires this
+    // again to refresh.
+    function notifyServerComponentChanges() {
+        if (hasCompilationErrors()) return;
         sendHmr('server-component-changes', {
             type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES
         });
@@ -623,7 +686,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         if (updateInProgress) {
             pendingServerComponentChanges = true;
         } else {
-            sendServerComponentChanges();
+            notifyServerComponentChanges();
         }
     }
     function hasCompilationErrors() {
@@ -664,7 +727,8 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             if (state.turbopackUpdates.length > 0) {
                 sendToClient(client, {
                     type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.TURBOPACK_MESSAGE,
-                    data: state.turbopackUpdates
+                    data: state.turbopackUpdates,
+                    hmrVersion: String(clientHmrVersion)
                 });
                 state.turbopackUpdates.length = 0;
             }
@@ -673,6 +737,14 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     const sendEnqueuedMessagesDebounce = (0, _utils1.debounce)(sendEnqueuedMessages, 2);
     const sendHmr = (id, message)=>{
         pendingBuilding.flush();
+        if (message.type === _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES) {
+            if (!clientHmrEventHappened) {
+                clientHmrVersion++;
+                clientHmrEventHappened = true;
+            }
+            message.hmrVersion = String(clientHmrVersion);
+        }
+        hmrEventHappened = true;
         for (const client of [
             ...clientsWithoutHtmlRequestId,
             ...clientsByHtmlRequestId.values()
@@ -680,7 +752,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             var _clientStates_get;
             (_clientStates_get = clientStates.get(client)) == null ? void 0 : _clientStates_get.messages.set(id, message);
         }
-        hmrEventHappened = true;
         sendEnqueuedMessagesDebounce();
     };
     function sendTurbopackMessage(payload) {
@@ -697,6 +768,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             var _clientStates_get;
             (_clientStates_get = clientStates.get(client)) == null ? void 0 : _clientStates_get.turbopackUpdates.push(payload);
         }
+        if (!clientHmrEventHappened) {
+            clientHmrVersion++;
+            clientHmrEventHappened = true;
+        }
         hmrEventHappened = true;
         sendEnqueuedMessagesDebounce();
     }
@@ -712,7 +787,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             for await (const change of changed){
                 (0, _utils2.processIssues)(currentEntryIssues, key, change, false, true);
                 // TODO: Get an actual content hash from Turbopack.
-                const message = await createMessage(change, String(++hmrHash));
+                const message = await createMessage(change, String(++serverComponentsHmrRefreshVersion));
                 if (message) {
                     sendHmr(key, message);
                 }
@@ -745,16 +820,20 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         if (!state || state.subscriptions.has(id)) {
             return;
         }
-        const subscription = project.hmrEvents(id, _swc.HmrTarget.Client);
+        const subscription = project.clientHmrEvents(id);
         state.subscriptions.set(id, subscription);
-        // The subscription will always emit once, which is the initial
-        // computation. This is not a change, so swallow it.
+        // Baseline capture and subscription setup are not atomic, so the first
+        // emission can be a real update. Ignore only the usual issues-only result.
         try {
-            await subscription.next();
+            const initial = await subscription.next();
+            if (!initial.done && initial.value.value.type !== 'issues') {
+                (0, _utils2.processIssues)(state.clientIssues, key, initial.value, false, true);
+                sendTurbopackMessage(initial.value.value);
+            }
             for await (const data of subscription){
                 (0, _utils2.processIssues)(state.clientIssues, key, data, false, true);
-                if (data.type !== 'issues') {
-                    sendTurbopackMessage(data);
+                if (data.value.type !== 'issues') {
+                    sendTurbopackMessage(data.value);
                 }
             }
         } catch (e) {
@@ -790,22 +869,23 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             // Always process issues/diagnostics, even if there are no entrypoints yet
             (0, _turbopackutils.processTopLevelIssues)(currentTopLevelIssues, entrypoints);
             // Certain crtical issues prevent any entrypoints from being constructed so return early
-            if (!('routes' in entrypoints)) {
-                (0, _printbuilderrors.printBuildErrors)(entrypoints, true);
+            if (!('routes' in entrypoints.value)) {
+                (0, _printbuilderrors.printBuildErrors)(entrypoints, true, {
+                    strictRouteMatchingDefaultWarning: (0, _strictroutematchingconfig.getStrictRouteMatchingDefaultWarning)(nextConfig)
+                });
                 currentEntriesHandlingResolve();
                 currentEntriesHandlingResolve = undefined;
                 continue;
             }
-            const routes = entrypoints.routes;
-            const existingRoutes = [
-                ...currentEntrypoints.app.keys(),
-                ...currentEntrypoints.page.keys()
-            ];
-            const newRoutes = [
+            const routes = entrypoints.value.routes;
+            const prevRouteKeys = previousRouteKeys;
+            const addedRoutes = prevRouteKeys ? [
                 ...routes.keys()
-            ];
-            const addedRoutes = newRoutes.filter((route)=>!currentEntrypoints.app.has(route) && !currentEntrypoints.page.has(route));
-            const removedRoutes = existingRoutes.filter((route)=>!routes.has(route));
+            ].filter((route)=>!prevRouteKeys.has(route)) : [];
+            const removedRoutes = prevRouteKeys ? [
+                ...prevRouteKeys
+            ].filter((route)=>!routes.has(route)) : [];
+            previousRouteKeys = new Set(routes.keys());
             await (0, _turbopackutils.handleEntrypoints)({
                 entrypoints: entrypoints,
                 currentEntrypoints,
@@ -825,8 +905,8 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     serverFields,
                     hooks: {
                         handleWrittenEndpoint: (id, result, forceDeleteCache)=>{
-                            currentWrittenEntrypoints.set(id, result);
-                            return clearRequireCache(id, result, {
+                            currentWrittenEntrypoints.set(id, result.value);
+                            return clearRequireCache(id, result.value, {
                                 force: forceDeleteCache
                             });
                         },
@@ -839,8 +919,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     }
                 }
             });
-            // Reload matchers when the files have been compiled
-            await (0, _setupdevbundler.propagateServerField)(opts, 'reloadMatchers', undefined);
             if (addedRoutes.length > 0 || removedRoutes.length > 0) {
                 // When the list of routes changes a new manifest should be fetched for Pages Router.
                 hotReloader.send({
@@ -888,7 +966,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             isSrcDir: opts.isSrcDir
         }),
         (0, _middlewareturbopack.getSourceMapMiddleware)(project),
-        (0, _getnexterrorfeedbackmiddleware.getNextErrorFeedbackMiddleware)(opts.telemetry),
         (0, _getdevoverlayfontmiddleware.getDevOverlayFontMiddleware)(),
         (0, _devindicatormiddleware.getDisableDevIndicatorMiddleware)(),
         (0, _restartdevservermiddleware.getRestartDevServerMiddleware)({
@@ -932,22 +1009,14 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             dynamicRoutes: opts.fsChecker.getDynamicRoutes()
                         });
                         if ('notFound' in resolved) {
-                            const err = Object.defineProperty(new Error(`no route matched for path "${resolved.pathname}"`), "__NEXT_ERROR_CODE", {
-                                value: "E1277",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            const err = new Error(`no route matched for path "${resolved.pathname}"`);
                             err.code = 'ENOENT';
                             throw err;
                         }
                         page = resolved.routeSpecifier;
                     } else {
                         // Tool handler rejects the empty case; defend the boundary.
-                        throw Object.defineProperty(new Error('compileRoute: either routeSpecifier or path is required'), "__NEXT_ERROR_CODE", {
-                            value: "E1278",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error('compileRoute: either routeSpecifier or path is required');
                     }
                     // ensurePage uses findPagePathData when no definition is provided,
                     // which calls normalizePagePath("/") → "/index" then findPageFile
@@ -1067,7 +1136,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         serverStats: null,
         edgeServerStats: null,
         async run (req, res, _parsedUrl) {
-            var _req_url;
+            var _req_url, _req_url1;
             // intercept page chunks request and ensure them with turbopack
             if ((_req_url = req.url) == null ? void 0 : _req_url.startsWith('/_next/static/chunks/pages/')) {
                 const params = (0, _hotreloadersharedutils.matchNextPageBundleRequest)(req.url);
@@ -1082,6 +1151,27 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     }).catch(console.error);
                 }
             }
+            // Requesting the manifest chunk of a lazily compiled dynamic import is what activates it,
+            // so the owning entrypoints have to be rebuilt before the static handler reads it off disk.
+            if (lazyDynamicImports && ((_req_url1 = req.url) == null ? void 0 : _req_url1.startsWith('/_next/static/chunks/')) && req.url.includes('lazy-compilation-')) {
+                // Turbopack names chunks relative to `/_next`, and so does `AssetMapper`.
+                const chunkPath = decodeURIComponent(req.url.split('?')[0].slice('/_next/'.length));
+                const keys = assetMapper.getKeysByAsset(chunkPath);
+                try {
+                    if (keys.length > 0 && await project.activateLazyChunk(chunkPath)) {
+                        for (const key of keys){
+                            await hotReloader.ensurePage({
+                                page: (0, _entrykey.splitEntryKey)(key).page,
+                                clientOnly: false,
+                                definition: undefined,
+                                url: req.url
+                            });
+                        }
+                    }
+                } catch (err) {
+                    console.error(err);
+                }
+            }
             for (const middleware of middlewares){
                 let calledNext = false;
                 await middleware(req, res, ()=>{
@@ -1143,7 +1233,17 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     turbopackUpdates: [],
                     subscriptions
                 });
+                if (runtimeErrorStates) {
+                    for (const message of runtimeErrorStates.values()){
+                        sendToClient(client, message);
+                    }
+                }
+                const runtimeErrorStateHandler = nextConfig.experimental.exposeRuntimeErrorsToHMR || Boolean(process.env.__NEXT_EXPOSE_RUNTIME_ERRORS_TO_HMR) ? (0, _runtimeerrorstate.createRuntimeErrorStateHandler)((message)=>hotReloader.send({
+                        ...message,
+                        htmlRequestId
+                    })) : undefined;
                 client.on('close', ()=>{
+                    runtimeErrorStateHandler == null ? void 0 : runtimeErrorStateHandler.dispose();
                     // Remove active subscriptions
                     for (const subscription of subscriptions.values()){
                         subscription.return == null ? void 0 : subscription.return.call(subscription);
@@ -1207,6 +1307,11 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             {
                                 break;
                             }
+                        case _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.RUNTIME_ERRORS:
+                            {
+                                void (runtimeErrorStateHandler == null ? void 0 : runtimeErrorStateHandler.handle(parsedData).catch(()=>{}));
+                                break;
+                            }
                         case 'mcp-error-state-response':
                             {
                                 (0, _geterrors.handleErrorStateResponse)(parsedData.requestId, parsedData.errorState, parsedData.url);
@@ -1220,16 +1325,19 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         default:
                             // Might be a Turbopack message...
                             if (!parsedData.type) {
-                                throw Object.defineProperty(new Error(`unrecognized HMR message "${data}"`), "__NEXT_ERROR_CODE", {
-                                    value: "E155",
-                                    enumerable: false,
-                                    configurable: true
-                                });
+                                throw new Error(`unrecognized HMR message "${data}"`);
                             }
                     }
                     // Turbopack messages
                     switch(parsedData.type){
                         case 'turbopack-subscribe':
+                            if (parsedData.hmrVersion !== undefined && parsedData.hmrVersion !== String(clientHmrVersion)) {
+                                sendToClient(client, {
+                                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.RELOAD_PAGE,
+                                    data: 'HMR hash mismatch'
+                                });
+                                break;
+                            }
                             subscribeToClientHmrEvents(client, parsedData.path);
                             break;
                         case 'turbopack-unsubscribe':
@@ -1237,18 +1345,15 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             break;
                         default:
                             if (!parsedData.event) {
-                                throw Object.defineProperty(new Error(`unrecognized Turbopack HMR message "${data}"`), "__NEXT_ERROR_CODE", {
-                                    value: "E492",
-                                    enumerable: false,
-                                    configurable: true
-                                });
+                                throw new Error(`unrecognized Turbopack HMR message "${data}"`);
                             }
                     }
                 });
                 const turbopackConnectedMessage = {
                     type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.TURBOPACK_CONNECTED,
                     data: {
-                        sessionId
+                        sessionId,
+                        hmrVersion: String(clientHmrVersion)
                     }
                 };
                 sendToClient(client, turbopackConnectedMessage);
@@ -1277,6 +1382,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         warnings: [],
                         hash: '',
                         versionInfo,
+                        hasVulnerabilityInsight,
                         debug: {
                             devtoolsFrontendUrl
                         },
@@ -1289,6 +1395,13 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             });
         },
         send (action) {
+            if (runtimeErrorStates && action.type === _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.RUNTIME_ERRORS) {
+                if (action.errors.length === 0) {
+                    runtimeErrorStates.delete(action.clientId);
+                } else {
+                    runtimeErrorStates.set(action.clientId, action);
+                }
+            }
             const payload = JSON.stringify(action);
             for (const client of [
                 ...clientsWithoutHtmlRequestId,
@@ -1298,13 +1411,9 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             }
         },
         getServerComponentsHmrRefreshHash () {
-            // The current server-components generation. Only the change subscription
-            // (an actual recompile) advances `hmrHash`; reloads and config
-            // invalidations don't, so the value stays stable across requests until a
-            // real edit. Returned unconditionally (`"0"` before the first edit) so
-            // `"use cache"` keys are present and consistent for every request,
-            // mirroring webpack's always-present `stats.hash`.
-            return String(hmrHash);
+            // Only a change subscription advances the refresh version, so reloads
+            // and config invalidations leave cache keys stable until a real edit.
+            return `${sessionId}-${serverComponentsHmrRefreshVersion}`;
         },
         sendToLegacyClients (action) {
             const payload = JSON.stringify(action);
@@ -1392,33 +1501,21 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     } else if ((0, _utils2.isWellKnownError)(issue)) {
                         _log.error(formattedIssue);
                     }
-                    return Object.defineProperty(new Error(formattedIssue), "__NEXT_ERROR_CODE", {
-                        value: "E394",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    return new Error(formattedIssue);
                 }).filter((error)=>error !== null);
             }
             // Otherwise, return all errors across pages
             const errors = [];
             for (const issue of topLevelIssues){
                 if (issue.severity !== 'warning') {
-                    errors.push(Object.defineProperty(new Error((0, _utils2.formatIssue)(issue)), "__NEXT_ERROR_CODE", {
-                        value: "E394",
-                        enumerable: false,
-                        configurable: true
-                    }));
+                    errors.push(new Error((0, _utils2.formatIssue)(issue)));
                 }
             }
             for (const entryIssues of currentEntryIssues.values()){
                 for (const issue of entryIssues.values()){
                     if (issue.severity !== 'warning') {
                         const message = (0, _utils2.formatIssue)(issue);
-                        errors.push(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                            value: "E394",
-                            enumerable: false,
-                            configurable: true
-                        }));
+                        errors.push(new Error(message));
                     } else {
                         (0, _turbopackutils.printNonFatalIssue)(issue);
                     }
@@ -1426,15 +1523,17 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             }
             return errors;
         },
-        async invalidate ({ // .env files or tsconfig/jsconfig change
-        reloadAfterInvalidation }) {
+        async invalidate ({ reloadAfterInvalidation }) {
             if (reloadAfterInvalidation) {
+                await (serverHmr == null ? void 0 : serverHmr.reset());
                 for (const [key, entrypoint] of currentWrittenEntrypoints){
                     clearRequireCache(key, entrypoint, {
                         force: true
                     });
                 }
                 await (0, _renderserver.clearAllModuleContexts)();
+                // Not `notifyServerComponentChanges`: an invalidation must announce even
+                // while errors stand, since it is what drops the stale graph.
                 this.send({
                     type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES
                 });
@@ -1500,9 +1599,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             hooks: {
                                 subscribeToChanges: subscribeToClientChanges,
                                 handleWrittenEndpoint: (id, result, forceDeleteCache)=>{
-                                    currentWrittenEntrypoints.set(id, result);
-                                    assetMapper.setPathsForKey(id, result.clientPaths);
-                                    return clearRequireCache(id, result, {
+                                    currentWrittenEntrypoints.set(id, result.value);
+                                    assetMapper.setPathsForKey(id, result.value.clientPaths);
+                                    serverAssetMapper.setPathsForKey(id, result.value.serverPaths.map(({ path })=>path));
+                                    return clearRequireCache(id, result.value, {
                                         force: forceDeleteCache
                                     });
                                 }
@@ -1531,13 +1631,14 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 // since this can happen when app pages make
                 // api requests to page API routes.
                 if (isApp && route.type === 'page') {
-                    throw Object.defineProperty(new Error(`mis-matched route type: isApp && page for ${page}`), "__NEXT_ERROR_CODE", {
-                        value: "E373",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`mis-matched route type: isApp && page for ${page}`);
                 }
                 const finishBuilding = startBuilding(pathname, requestUrl, false);
+                // Set by `handleWrittenEndpoint` below, so the pull is gated on the
+                // same predicate as the require-cache handling rather than a second,
+                // coarser reading of `route.type`.
+                let shouldPullServerHmr = false;
+                let serverHmrEntryPaths = [];
                 try {
                     await (0, _turbopackutils.handleRouteType)({
                         dev,
@@ -1557,15 +1658,24 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             subscribeToChanges: subscribeToChanges ? subscribeToClientChanges : async ()=>{},
                             handleServerComponentChanges,
                             handleWrittenEndpoint: (id, result, forceDeleteCache)=>{
-                                currentWrittenEntrypoints.set(id, result);
-                                assetMapper.setPathsForKey(id, result.clientPaths);
-                                return clearRequireCache(id, result, {
+                                currentWrittenEntrypoints.set(id, result.value);
+                                assetMapper.setPathsForKey(id, result.value.clientPaths);
+                                serverAssetMapper.setPathsForKey(id, result.value.serverPaths.map(({ path })=>path));
+                                shouldPullServerHmr ||= participatesInServerHmr(id, result.value);
+                                if (result.value.serverHmrEntryPaths.length > 0) {
+                                    serverHmrEntryPaths = result.value.serverHmrEntryPaths;
+                                }
+                                return clearRequireCache(id, result.value, {
                                     force: forceDeleteCache
                                 });
-                            },
-                            serverFastRefresh
+                            }
                         }
                     });
+                    // The only server HMR pull, driven by the request being built — which
+                    // is what makes evaluating a changed module lazy.
+                    if (shouldPullServerHmr && serverHmrEntryPaths.length > 0) {
+                        await (serverHmr == null ? void 0 : serverHmr.apply(serverHmrEntryPaths));
+                    }
                 } finally{
                     finishBuilding();
                     // Remove non-deferred entry from building set
@@ -1587,6 +1697,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             }
             clientsWithoutHtmlRequestId.clear();
             clientsByHtmlRequestId.clear();
+            runtimeErrorStates == null ? void 0 : runtimeErrorStates.clear();
         }
     };
     handleEntrypointsSubscription().catch((err)=>{
@@ -1627,7 +1738,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         pendingBuilding.cancel();
                         if (pendingServerComponentChanges) {
                             pendingServerComponentChanges = false;
-                            sendServerComponentChanges();
+                            notifyServerComponentChanges();
                         }
                         sendEnqueuedMessages();
                         function addToErrorsMap(errorsMap, issueMap) {
@@ -1664,7 +1775,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                                 // Report the current version without advancing it: a completed
                                 // compilation is not itself an edit, and this hash is not
                                 // consumed by the Turbopack client.
-                                hash: String(hmrHash),
+                                hash: String(serverComponentsHmrRefreshVersion),
                                 errors: [
                                     ...clientErrors.values()
                                 ],
@@ -1677,6 +1788,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             _log.event(`Compiled in ${timeMessage}`);
                             hmrEventHappened = false;
                         }
+                        clientHmrEventHappened = false;
                         // Call onBeforeDeferredEntries after compilation completes during HMR
                         // This ensures the callback is invoked even when non-deferred entries change
                         // Use debounced function to prevent rapid-fire calls from turbopack updates
@@ -1693,19 +1805,47 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         console.error(err);
         process.exit(1);
     });
-    // Tell browsers to refetch RSC (soft refresh, not full page reload).
-    // Skip while there are outstanding compilation errors: an RSC refetch would
-    // 500 and force a full-page navigation, losing client state (e.g. recovering
-    // from a syntax error). A subsequent successful compile/apply fires this
-    // again to refresh.
-    function notifyServerComponentChanges() {
-        if (hasCompilationErrors()) return;
-        hotReloader.send({
-            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES
+    if (lazyDynamicImportsSSR) {
+        const previousEnsureChunk = globalThis.__turbopack_ensure_chunk__;
+        const ensureChunk = async (chunkPath)=>{
+            if (!chunkPath.includes('lazy-compilation-')) return;
+            const keys = serverAssetMapper.getKeysByAsset(chunkPath);
+            if (keys.length === 0 || !await project.activateLazyChunk(chunkPath)) {
+                return;
+            }
+            for (const key of keys){
+                const { page, type } = (0, _entrykey.splitEntryKey)(key);
+                await hotReloader.ensurePage({
+                    page,
+                    clientOnly: false,
+                    definition: undefined
+                });
+                if (type === 'app') {
+                    (0, _loadmanifestexternal.clearManifestCache)((0, _path.join)(distDir, 'server', 'app', page.replace(/%5F/g, '_') + '_' + _constants.CLIENT_REFERENCE_MANIFEST + '.js'));
+                    const clientReferenceManifest = await (0, _loadcomponents.loadClientReferenceManifestForPage)(distDir, page, 1);
+                    if (clientReferenceManifest) {
+                        (0, _manifestssingleton.setManifestsSingleton)({
+                            page,
+                            clientReferenceManifest,
+                            serverActionsManifest: (0, _loadmanifestexternal.loadManifest)((0, _path.join)(distDir, 'server', _constants.SERVER_REFERENCE_MANIFEST + '.json'), false)
+                        });
+                    }
+                }
+            }
+            (0, _requirecache.deleteCache)([
+                (0, _path.join)(distDir, chunkPath)
+            ]);
+        };
+        globalThis.__turbopack_ensure_chunk__ = ensureChunk;
+        opts.onDevServerCleanup == null ? void 0 : opts.onDevServerCleanup.call(opts, async ()=>{
+            if (globalThis.__turbopack_ensure_chunk__ === ensureChunk) {
+                globalThis.__turbopack_ensure_chunk__ = previousEnsureChunk;
+            }
         });
     }
+    let serverHmr;
     if (serverFastRefresh) {
-        setupServerHmr(project, {
+        serverHmr = setupServerHmr(project, {
             reEvaluateAllModulesExpensive: async ()=>{
                 // Evict every server-HMR-managed chunk from `require.cache`.
                 // Trailing `sep` so e.g. `server/chunks-other/...` doesn't match.
@@ -1727,7 +1867,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 // validation worker cannot repair its own either, so it is dropped and
                 // the next validation loads the build output afresh.
                 (0, _devvalidationworkerpool.dropDevValidationWorker)();
-                notifyServerComponentChanges();
             },
             onApplied: (chunkPaths)=>{
                 // Clear the evalManifest() shared cache for each updated chunk so the
@@ -1746,7 +1885,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     filePaths: manifestPaths,
                     evictModules: false
                 });
-                notifyServerComponentChanges();
             }
         });
     }