@evoscientist/webui 0.2.4 → 0.2.6

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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "createHotReloaderTurbopack", {
     }
 });
 const _promises = require("fs/promises");
+const _fs = require("fs");
 const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
 const _path = require("path");
 const _url = require("url");
@@ -21,7 +22,9 @@ const _constants = require("../../shared/lib/constants");
 const _middlewareturbopack = require("./middleware-turbopack");
 const _utils = require("../../shared/lib/utils");
 const _utils1 = require("../utils");
+const _loadmanifestexternal = require("../load-manifest.external");
 const _requirecache = require("./require-cache");
+const _devvalidationworkerpool = require("./dev-validation-worker-pool");
 const _renderserver = require("../lib/render-server");
 const _denormalizepagepath = require("../../shared/lib/page-path/denormalize-page-path");
 const _trace = require("../../trace");
@@ -37,6 +40,7 @@ const _apppaths = require("../../shared/lib/router/utils/app-paths");
 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");
@@ -44,15 +48,20 @@ 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 _deferredemit = require("../../shared/lib/turbopack/deferred-emit");
 const _getsupportedbrowsers = require("../../build/get-supported-browsers");
 const _printbuilderrors = require("../../build/print-build-errors");
 const _receivelogs = require("./browser-logs/receive-logs");
 const _normalizepath = require("../../lib/normalize-path");
+const _turbopackcacheseed = require("../../lib/turbopack-cache-seed");
 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");
+const _formatcompilationissues = require("../mcp/tools/utils/format-compilation-issues");
+const _requestinsights = require("../lib/trace/request-insights");
+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");
@@ -110,96 +119,121 @@ 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());
-function setupServerHmr(project, { clear }) {
-    const serverHmrSubscriptions = new Map();
-    /**
-   * Subscribe to HMR updates for a server chunk.
-   * @param chunkPath - Server chunk output path (e.g., "server/chunks/ssr/..._.js")
-   */ function subscribeToServerHmr(chunkPath) {
-        if (serverHmrSubscriptions.has(chunkPath)) {
-            return;
+/** Output directory (relative to `distDir`) of server-HMR-managed chunks. */ const SERVER_HMR_CHUNKS_DIR = (0, _path.join)('server', 'chunks');
+/**
+ * Collects the output chunk paths touched by a partial HMR update. Both
+ * single-chunk `EcmascriptMergedUpdate`s and `ChunkListUpdate`s (which nest
+ * per-chunk deltas inside `merged`) are flattened so the manifest cache can be
+ * invalidated for every affected chunk after a successful apply.
+ */ function collectUpdatedChunkPaths(instruction) {
+    const paths = new Set();
+    if (instruction.type === 'EcmascriptMergedUpdate') {
+        for (const chunkPath of Object.keys(instruction.chunks ?? {})){
+            paths.add(chunkPath);
         }
-        const subscription = project.hmrEvents(chunkPath, _swc.HmrTarget.Server);
-        serverHmrSubscriptions.set(chunkPath, subscription);
-        (async ()=>{
-            // Skip initial state
-            await subscription.next();
-            for await (const result of subscription){
-                const update = result;
-                // Fully re-evaluate all chunks from disk. Clears the module cache and
-                // notifies browsers to refetch RSC.
-                if (update.type === 'restart') {
-                    await clear();
-                    continue;
-                }
-                if (update.type !== 'partial') {
-                    continue;
-                }
-                const instruction = update.instruction;
-                if (!instruction || instruction.type !== 'EcmascriptMergedUpdate') {
+    } else if (instruction.type === 'ChunkListUpdate') {
+        for (const chunkPath of Object.keys(instruction.chunks ?? {})){
+            paths.add(chunkPath);
+        }
+        for (const merged of instruction.merged ?? []){
+            for (const chunkPath of Object.keys(merged.chunks ?? {})){
+                paths.add(chunkPath);
+            }
+        }
+    } else {
+        throw Object.defineProperty(new Error(`[Server HMR] unreachable: unknown HMR instruction type ${instruction.type}`), "__NEXT_ERROR_CODE", {
+            value: "E1459",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    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;
+            }
+            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;
                 }
-                if (typeof __turbopack_server_hmr_apply__ === 'function') {
-                    const applied = __turbopack_server_hmr_apply__(update);
-                    if (!applied) {
-                        await clear();
-                    }
+                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);
                 }
+            } else {
+                await reEvaluateAllModulesExpensive();
             }
-        })().catch(async (err)=>{
-            console.error('[Server HMR] Subscription error:', err);
-            serverHmrSubscriptions.delete(chunkPath);
-            await clear();
-        });
+        }
     }
-    // Listen to the Rust bindings update us on changing server HMR chunk paths
+    // 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 ()=>{
-        try {
-            const serverHmrChunkPaths = project.hmrChunkNamesSubscribe(_swc.HmrTarget.Server);
-            // Process chunk paths (both initial and subsequent updates)
-            for await (const data of serverHmrChunkPaths){
-                const currentChunkPaths = new Set(data.chunkNames.filter((path)=>path.endsWith('.js')));
-                // Clean up subscriptions for removed chunk paths (like when pages are deleted)
-                const chunkPathsToRemove = [];
-                for (const chunkPath of serverHmrSubscriptions.keys()){
-                    if (!currentChunkPaths.has(chunkPath)) {
-                        chunkPathsToRemove.push(chunkPath);
-                    }
-                }
-                for (const chunkPath of chunkPathsToRemove){
-                    var _subscription_return;
-                    const subscription = serverHmrSubscriptions.get(chunkPath);
-                    subscription == null ? void 0 : (_subscription_return = subscription.return) == null ? void 0 : _subscription_return.call(subscription);
-                    serverHmrSubscriptions.delete(chunkPath);
-                }
-                // Subscribe to HMR events for new server chunks
-                for (const chunkPath of currentChunkPaths){
-                    if (!serverHmrSubscriptions.has(chunkPath)) {
-                        subscribeToServerHmr(chunkPath);
-                    }
-                }
+        for(;;){
+            try {
+                await runSubscription();
+                return;
+            } catch (err) {
+                console.error('[Server HMR] Subscription error, resubscribing:', err);
+                await reEvaluateAllModulesExpensive();
+                await new Promise((resolve)=>setTimeout(resolve, 1000));
             }
-        } catch (err) {
-            console.error('[Server HMR Setup] Error in chunk path subscription:', err);
         }
     })();
-    return serverHmrSubscriptions;
 }
-/**
- * Replaces turbopack:///[project] with the specified project in the `source` field.
- */ function rewriteTurbopackSources(projectRoot, sourceMap) {
-    if ('sections' in sourceMap) {
-        for (const section of sourceMap.sections){
-            rewriteTurbopackSources(projectRoot, section.map);
-        }
-    } else {
-        for(let i = 0; i < sourceMap.sources.length; i++){
-            sourceMap.sources[i] = (0, _url.pathToFileURL)((0, _path.join)(projectRoot, sourceMap.sources[i].replace(/turbopack:\/\/\/\[project\]/, ''))).toString();
-        }
-    }
-}
-function getSourceMapFromTurbopack(project, projectRoot, sourceURL) {
+function getSourceMapFromTurbopack(project, sourceURL) {
     let sourceMapJson = null;
     try {
         sourceMapJson = project.getSourceMapSync(sourceURL);
@@ -207,15 +241,43 @@ function getSourceMapFromTurbopack(project, projectRoot, sourceURL) {
     if (sourceMapJson === null) {
         return undefined;
     } else {
-        const payload = JSON.parse(sourceMapJson);
-        // The sourcemap from Turbopack is not yet written to disk so its `sources`
-        // are not absolute paths yet. We need to rewrite them to be absolute paths.
-        rewriteTurbopackSources(projectRoot, payload);
-        return payload;
+        return JSON.parse(sourceMapJson);
     }
 }
+function getSourceMapURLFromTurbopack(distDir, scriptNameOrSourceURL) {
+    // React invokes this with the raw stack-frame filename, which arrives
+    // either as an absolute filesystem path or as a `file:` URL. Anything else
+    // (`file:` URLs with a query are eval'd server HMR modules carrying inline
+    // source maps, `webpack-internal://`, `node:internal/...`, `<anonymous>`,
+    // ...) is not something we have an emitted source map for.
+    let scriptPath = scriptNameOrSourceURL;
+    if (scriptNameOrSourceURL.startsWith('file://')) {
+        if (scriptNameOrSourceURL.includes('?')) {
+            return null;
+        }
+        try {
+            scriptPath = (0, _url.fileURLToPath)(scriptNameOrSourceURL);
+        } catch  {
+            return null;
+        }
+    }
+    if (!(0, _path.isAbsolute)(scriptPath)) {
+        return null;
+    }
+    // Only chunks emitted into `distDir` have an on-disk source map to point at.
+    const relativePath = (0, _path.relative)(distDir, scriptPath);
+    if (relativePath.startsWith('..') || // On Windows an absolute path on a different drive is returned unchanged
+    // rather than as a `..`-prefixed relative path.
+    (0, _path.isAbsolute)(relativePath)) {
+        return null;
+    }
+    // The emitted source map lives next to its chunk with a `.map` suffix (see
+    // `SourceMapAsset::path`). Encode through `pathToFileURL` so any special
+    // characters in the path are escaped into a well-formed `file:` URL.
+    return (0, _url.pathToFileURL)(scriptPath + '.map').href;
+}
 async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetch, lockfile, serverFastRefresh) {
-    var _opts_nextConfig_turbopack, _nextConfig_watchOptions, _opts_nextConfig_experimental;
+    var _opts_nextConfig_turbopack, _nextConfig_watchOptions;
     const dev = true;
     const buildId = 'development';
     const { nextConfig, dir: projectPath } = opts;
@@ -240,7 +302,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.2.6"
+        version: "16.3.3"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -262,6 +324,12 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     const supportedBrowsers = (0, _getsupportedbrowsers.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;
+    if (nextConfig.experimental.turbopackSeedCacheFromWorktree) {
+        (0, _turbopackcacheseed.seedTurbopackCacheIfNeeded)({
+            projectDir: projectPath,
+            distDir
+        });
+    }
     const project = await bindings.turbo.createProject({
         rootPath,
         projectPath: (0, _normalizepath.normalizePath)((0, _path.relative)(rootPath, projectPath) || '.'),
@@ -294,10 +362,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
-        nextVersion: "16.2.6",
+        nextVersion: "16.3.3",
         serverHmr: serverFastRefresh
     }, {
-        memoryLimit: (_opts_nextConfig_experimental = opts.nextConfig.experimental) == null ? void 0 : _opts_nextConfig_experimental.turbopackMemoryLimit,
+        turbopackMemoryEviction: opts.nextConfig.experimental.turbopackMemoryEvictionMode,
         isShortSession: false
     });
     (0, _compilationevents.backgroundLogCompilationEvents)(project, {
@@ -309,12 +377,18 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         ],
         parentSpan: hotReloaderSpan
     });
-    (0, _patcherrorinspect.setBundlerFindSourceMapImplementation)(getSourceMapFromTurbopack.bind(null, project, projectPath));
+    (0, _patcherrorinspect.setBundlerFindSourceMapImplementation)(getSourceMapFromTurbopack.bind(null, project));
+    let canonicalDistDir = distDir;
+    try {
+        canonicalDistDir = (0, _fs.realpathSync)(distDir);
+    } catch  {}
+    (0, _sourcemaps.setBundlerFindSourceMapURLImplementation)(getSourceMapURLFromTurbopack.bind(null, canonicalDistDir));
     // Set up code frame renderer using native bindings
     const { installCodeFrameSupport } = require('../lib/install-code-frame');
     installCodeFrameSupport();
     opts.onDevServerCleanup == null ? void 0 : opts.onDevServerCleanup.call(opts, async ()=>{
         (0, _patcherrorinspect.setBundlerFindSourceMapImplementation)(()=>undefined);
+        (0, _sourcemaps.setBundlerFindSourceMapURLImplementation)(()=>null);
         await project.onExit();
         await (lockfile == null ? void 0 : lockfile.unlock());
     });
@@ -415,9 +489,11 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         } else {
             // Figure out if the server files have changed
             let hasChange = false;
+            const currentPaths = new Set();
             for (const { path, contentHash } of writtenEndpoint.serverPaths){
                 // We ignore source maps
                 if (path.endsWith('.map')) continue;
+                currentPaths.add(path);
                 const localKey = `${key}:${path}`;
                 const localHash = serverPathState.get(localKey);
                 const globalHash = serverPathState.get(path);
@@ -434,28 +510,37 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     }
                 }
             }
+            const localKeyPrefix = `${key}:`;
+            for (const pathKey of serverPathState.keys()){
+                if (pathKey.startsWith(localKeyPrefix) && !currentPaths.has(pathKey.slice(localKeyPrefix.length))) {
+                    serverPathState.delete(pathKey);
+                    hasChange = true;
+                }
+            }
             if (!hasChange) {
                 return false;
             }
         }
+        // Edge does not participate in server HMR.
+        if (writtenEndpoint.type === 'edge') {
+            void (0, _renderserver.clearAllModuleContexts)();
+        }
         const serverPaths = writtenEndpoint.serverPaths.map(({ path: p })=>(0, _path.join)(distDir, p));
-        const { type: entryType, page: entryPage } = (0, _entrykey.splitEntryKey)(key);
+        const { type: entryType } = (0, _entrykey.splitEntryKey)(key);
         // Server HMR applies to App Router entries built with the Turbopack Node.js
-        // runtime: app pages and regular route handlers. Edge routes, Pages Router
-        // pages, middleware/instrumentation, and metadata routes (manifest.ts,
-        // robots.ts, sitemap.ts, icon.tsx, etc.) are excluded. Metadata routes are
-        // excluded because they serve HTTP responses directly and must re-execute
-        // on every request to pick up file changes; the in-place module update
-        // model of Server HMR does not apply to them.
-        const usesServerHmr = serverFastRefresh && entryType === 'app' && writtenEndpoint.type !== 'edge' && !(0, _ismetadataroute.isMetadataRoute)(entryPage);
+        // 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 serverChunksPrefix = SERVER_HMR_CHUNKS_DIR + _path.sep;
         const filesToDelete = [];
         for (const file of serverPaths){
             (0, _renderserver.clearModuleContext)(file);
             const relativePath = (0, _path.relative)(distDir, file);
-            if (// For Pages Router, edge routes, middleware, and manifest files:
-            // clear the sharedCache in evalManifest(), Node.js require.cache,
-            // and edge runtime module contexts.
-            force || !usesServerHmr || !(serverHmrSubscriptions == null ? void 0 : serverHmrSubscriptions.has(relativePath))) {
+            if (// For Pages Router, edge routes, middleware, and any entry not
+            // participating in server HMR: clear the sharedCache in
+            // evalManifest(), Node.js require.cache, and edge runtime module
+            // contexts.
+            force || !usesServerHmr || !relativePath.startsWith(serverChunksPrefix)) {
                 filesToDelete.push(file);
             }
         }
@@ -502,9 +587,21 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             }
         };
     };
-    let serverHmrSubscriptions;
     let hmrEventHappened = false;
+    // A counter identifying the current version of the compiled 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
+    // how many clients are connected. It deliberately does not advance on `BUILT`
+    // 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;
+    // 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
+    // sending them if we quickly get a `built` message after a `building` message.
+    const pendingBuilding = new _deferredemit.DeferredEmit();
     const clientsWithoutHtmlRequestId = new Set();
     const clientsByHtmlRequestId = new Map();
     const cacheStatusesByHtmlRequestId = new Map();
@@ -513,15 +610,37 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         const data = typeof message.type === 'number' ? (0, _messages.createBinaryHmrMessageData)(message) : JSON.stringify(message);
         client.send(data);
     }
-    function sendEnqueuedMessages() {
+    let updateInProgress = false;
+    let pendingServerComponentChanges = false;
+    function sendServerComponentChanges() {
+        sendHmr('server-component-changes', {
+            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES
+        });
+    }
+    // Each announcement makes every client refetch its page, so an update's
+    // changes are announced once, on the update's end.
+    function handleServerComponentChanges() {
+        if (updateInProgress) {
+            pendingServerComponentChanges = true;
+        } else {
+            sendServerComponentChanges();
+        }
+    }
+    function hasCompilationErrors() {
         for (const [, issueMap] of currentEntryIssues){
             if ([
                 ...issueMap.values()
             ].filter((i)=>i.severity !== 'warning').length > 0) {
-                // During compilation errors we want to delay the HMR events until errors are fixed
-                return;
+                return true;
             }
         }
+        return false;
+    }
+    function sendEnqueuedMessages() {
+        if (hasCompilationErrors()) {
+            // During compilation errors we want to delay the HMR events until errors are fixed
+            return;
+        }
         for (const client of [
             ...clientsWithoutHtmlRequestId,
             ...clientsByHtmlRequestId.values()
@@ -553,6 +672,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const sendEnqueuedMessagesDebounce = (0, _utils1.debounce)(sendEnqueuedMessages, 2);
     const sendHmr = (id, message)=>{
+        pendingBuilding.flush();
         for (const client of [
             ...clientsWithoutHtmlRequestId,
             ...clientsByHtmlRequestId.values()
@@ -569,6 +689,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         //   They are currently not handled on the client at all, so might as well not send them for now.
         payload.diagnostics = [];
         payload.issues = [];
+        pendingBuilding.flush();
         for (const client of [
             ...clientsWithoutHtmlRequestId,
             ...clientsByHtmlRequestId.values()
@@ -793,7 +914,116 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 appDir: opts.appDir,
                 sendHmrMessage: (message)=>hotReloader.send(message),
                 getActiveConnectionCount: ()=>clientsWithoutHtmlRequestId.size + clientsByHtmlRequestId.size,
-                getDevServerUrl: ()=>process.env.__NEXT_PRIVATE_ORIGIN
+                getDevServerUrl: ()=>process.env.__NEXT_PRIVATE_ORIGIN,
+                getTurbopackProject: ()=>project,
+                compileRoute: async ({ routeSpecifier, path })=>{
+                    // Resolve the caller's input to a concrete route specifier. The
+                    // path-mode branch reuses the dev router's own live route table
+                    // (opts.fsChecker) — the same one resolve-routes.ts consults on
+                    // every incoming HTTP request — so first-match ordering and live
+                    // route updates are inherited for free.
+                    let page;
+                    if (routeSpecifier != null) {
+                        page = routeSpecifier;
+                    } else if (path != null) {
+                        const resolved = (0, _resolvepathtoroute.resolvePathToRoute)(path, {
+                            appFiles: opts.fsChecker.appFiles,
+                            pageFiles: opts.fsChecker.pageFiles,
+                            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
+                            });
+                            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
+                        });
+                    }
+                    // ensurePage uses findPagePathData when no definition is provided,
+                    // which calls normalizePagePath("/") → "/index" then findPageFile
+                    // looking for "index.tsx" — neither of which matches "page.tsx" in
+                    // the app dir. Pass a synthetic definition instead.
+                    //
+                    // currentEntrypoints.app is keyed by originalName which includes the
+                    // trailing /page or /route segment (e.g. "/page" for the root route,
+                    // "/blog/[slug]/page" for a dynamic page). Use normalizeAppPath to
+                    // strip that suffix and find the entry matching the user-facing route.
+                    let extraOptions = undefined;
+                    for (const [name] of currentEntrypoints.app){
+                        if ((0, _apppaths.normalizeAppPath)(name) === page) {
+                            extraOptions = {
+                                // Synthesize a definition so ensurePage bypasses findPagePathData.
+                                // Only page and bundlePath are used from the definition:
+                                // - page: the originalName used as the route key for currentEntrypoints lookup
+                                // - bundlePath: must start with "app/" to set isInsideAppDir=true
+                                definition: {
+                                    page: name,
+                                    bundlePath: `app${name}`,
+                                    filename: ''
+                                }
+                            };
+                            break;
+                        }
+                    }
+                    const ensureOpts = {
+                        page,
+                        // Compile both server and client bundles, matching what happens
+                        // on a real page navigation. Client-only compilation isn't a
+                        // meaningful MCP use case so we don't expose it as a knob.
+                        clientOnly: false,
+                        // Skip wiring HMR subscriptions: there is no client to receive
+                        // updates for routes compiled this way, and these subscriptions
+                        // are never unsubscribed (see TODOs in handleRouteType).
+                        subscribeToChanges: false,
+                        ...extraOptions
+                    };
+                    // Snapshot the current issue maps before compilation so we can
+                    // identify which entry keys were added or updated by this call.
+                    // processIssues always creates a new Map() reference, so identity
+                    // comparison detects changes even for re-compilations.
+                    const snapshotBefore = new Map(currentEntryIssues);
+                    // For app-page routes, processIssues is called with throwIssue=true,
+                    // meaning it throws ModuleBuildError when there are compile errors—but
+                    // it still writes the issues into currentEntryIssues before throwing.
+                    // Catch ModuleBuildError so we can read those issues and return them
+                    // as structured output rather than propagating the throw.
+                    let moduleBuildError;
+                    try {
+                        await hotReloader.ensurePage(ensureOpts);
+                    } catch (err) {
+                        if (err instanceof _utils2.ModuleBuildError) {
+                            moduleBuildError = err;
+                        } else {
+                            throw err;
+                        }
+                    }
+                    const rawIssues = [];
+                    for (const [key, issueMap] of currentEntryIssues){
+                        if (snapshotBefore.get(key) !== issueMap) {
+                            rawIssues.push(...issueMap.values());
+                        }
+                    }
+                    // If ensurePage threw ModuleBuildError but we found no new issues in
+                    // the map (shouldn't happen, but be safe), re-surface the original
+                    // error so its message and stack are preserved.
+                    if (moduleBuildError && rawIssues.length === 0) {
+                        throw moduleBuildError;
+                    }
+                    return {
+                        routeSpecifier: page,
+                        issues: (0, _formatcompilationissues.formatCompilationIssues)(rawIssues)
+                    };
+                }
             })
         ] : []
     ];
@@ -962,24 +1192,15 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             break;
                         case 'browser-logs':
                             {
-                                const browserToTerminalConfig = nextConfig.logging && nextConfig.logging.browserToTerminal;
-                                if (browserToTerminalConfig) {
-                                    await (0, _receivelogs.receiveBrowserLogsTurbopack)({
-                                        entries: parsedData.entries,
-                                        router: parsedData.router,
-                                        sourceType: parsedData.sourceType,
-                                        project,
-                                        projectPath,
-                                        distDir,
-                                        config: browserToTerminalConfig
-                                    });
-                                }
-                                break;
-                            }
-                        case 'client-file-logs':
-                            {
-                                // Always log to file regardless of terminal flag
-                                await (0, _receivelogs.handleClientFileLogs)(parsedData.logs);
+                                await (0, _receivelogs.receiveBrowserLogsTurbopack)({
+                                    entries: parsedData.entries,
+                                    router: parsedData.router,
+                                    sourceType: parsedData.sourceType,
+                                    project,
+                                    projectPath,
+                                    distDir,
+                                    config: nextConfig.logging && nextConfig.logging.browserToTerminal || false
+                                });
                                 break;
                             }
                         case 'ping':
@@ -1060,7 +1281,8 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             devtoolsFrontendUrl
                         },
                         devIndicator: _devindicatorserverstate.devIndicatorServerState,
-                        devToolsConfig
+                        devToolsConfig,
+                        requestInsights: nextConfig.experimental.requestInsights || (0, _requestinsights.isRequestInsightsEnabled)() ? (0, _requestinsights.getRequestInsightsSnapshot)() : undefined
                     };
                     sendToClient(client, syncMessage);
                 })();
@@ -1075,6 +1297,15 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 client.send(payload);
             }
         },
+        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);
+        },
         sendToLegacyClients (action) {
             const payload = JSON.stringify(action);
             // Clients with a request ID are inferred App Router clients. If Cache
@@ -1205,8 +1436,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 }
                 await (0, _renderserver.clearAllModuleContexts)();
                 this.send({
-                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES,
-                    hash: String(++hmrHash)
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES
                 });
             }
         },
@@ -1215,9 +1445,9 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         },
         async ensurePage ({ page: inputPage, // Unused parameters
         // clientOnly,
-        appPaths, definition, isApp, url: requestUrl }) {
+        appPaths, definition, isApp, url: requestUrl, subscribeToChanges = true }) {
             // When there is no route definition this is an internal file not a route the user added.
-            // Middleware and instrumentation are handled in turbpack-utils.ts handleEntrypoints instead.
+            // Middleware and instrumentation are handled in turbopack-utils.ts handleEntrypoints instead.
             if (!definition) {
                 if (inputPage === '/middleware') return;
                 if (inputPage === '/src/middleware') return;
@@ -1322,14 +1552,18 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         productionRewrites: undefined,
                         logErrors: true,
                         hooks: {
-                            subscribeToChanges: subscribeToClientChanges,
+                            // Pass a no-o subscribeToChanges to skip wiring HMR subscriptions for
+                            // one-shot compilations (e.g. compile_route MCP tool).
+                            subscribeToChanges: subscribeToChanges ? subscribeToClientChanges : async ()=>{},
+                            handleServerComponentChanges,
                             handleWrittenEndpoint: (id, result, forceDeleteCache)=>{
                                 currentWrittenEntrypoints.set(id, result);
                                 assetMapper.setPathsForKey(id, result.clientPaths);
                                 return clearRequireCache(id, result, {
                                     force: forceDeleteCache
                                 });
-                            }
+                            },
+                            serverFastRefresh
                         }
                     });
                 } finally{
@@ -1367,12 +1601,16 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         entrypoints: currentEntrypoints
     });
     async function handleProjectUpdates() {
+        const BUILDING_MESSAGE_DEFER_MS = 100;
         for await (const updateMessage of project.updateInfoSubscribe(30)){
             switch(updateMessage.updateType){
                 case 'start':
                     {
-                        hotReloader.send({
-                            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.BUILDING
+                        updateInProgress = true;
+                        pendingBuilding.schedule(BUILDING_MESSAGE_DEFER_MS, ()=>{
+                            hotReloader.send({
+                                type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.BUILDING
+                            });
                         });
                         // Mark that HMR has started and we need to call the callback after it settles
                         // This ensures onBeforeDeferredEntries will be called again during HMR
@@ -1385,6 +1623,12 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     }
                 case 'end':
                     {
+                        updateInProgress = false;
+                        pendingBuilding.cancel();
+                        if (pendingServerComponentChanges) {
+                            pendingServerComponentChanges = false;
+                            sendServerComponentChanges();
+                        }
                         sendEnqueuedMessages();
                         function addToErrorsMap(errorsMap, issueMap) {
                             for (const [key, issue] of issueMap){
@@ -1417,7 +1661,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             addErrors(clientErrors, state.clientIssues);
                             sendToClient(client, {
                                 type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.BUILT,
-                                hash: String(++hmrHash),
+                                // 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),
                                 errors: [
                                     ...clientErrors.values()
                                 ],
@@ -1446,13 +1693,24 @@ 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 (serverFastRefresh) {
-        serverHmrSubscriptions = setupServerHmr(project, {
-            clear: async ()=>{
-                // Clear Node's require cache of all Turbopack-built modules
-                const chunkPaths = [
-                    ...(serverHmrSubscriptions == null ? void 0 : serverHmrSubscriptions.keys()) ?? []
-                ].map((chunkPath)=>(0, _path.join)(distDir, chunkPath));
+        setupServerHmr(project, {
+            reEvaluateAllModulesExpensive: async ()=>{
+                // Evict every server-HMR-managed chunk from `require.cache`.
+                // Trailing `sep` so e.g. `server/chunks-other/...` doesn't match.
+                const serverChunksDir = (0, _path.join)(distDir, SERVER_HMR_CHUNKS_DIR) + _path.sep;
+                const chunkPaths = Object.keys(require.cache).filter((p)=>p.startsWith(serverChunksDir));
                 (0, _requirecache.deleteCache)(chunkPaths);
                 // Clear Turbopack's runtime caches
                 if (typeof __next__clear_chunk_cache__ === 'function') {
@@ -1461,16 +1719,34 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 // Reset the server HMR handler registry. All server runtime chunks are
                 // cleared from require.cache above; when they're next required they'll
                 // re-register into this Map and reinstall the routing dispatcher.
-                ;
                 globalThis.__turbopack_server_hmr_handlers__ = new Map();
                 // Clear all edge contexts
                 await (0, _renderserver.clearAllModuleContexts)();
                 resetFetch();
-                // Tell browsers to refetch RSC (soft refresh, not full page reload)
-                hotReloader.send({
-                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES,
-                    hash: String(++hmrHash)
+                // This thread gave up on repairing its module graph in place. The
+                // 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
+                // next RSC render picks up the HMR-applied module changes. Unlike
+                // a full restart, this does NOT clear require.cache — the HMR-applied
+                // modules in devModuleCache must persist for dep preservation.
+                const manifestPaths = chunkPaths.map((chunkPath)=>(0, _path.join)(distDir, chunkPath));
+                for (const manifestPath of manifestPaths){
+                    (0, _loadmanifestexternal.clearManifestCache)(manifestPath);
+                }
+                // This path clears the manifest cache without going through
+                // `deleteCache`, so `onCacheInvalidation` does not report it to the
+                // validation worker. Report it here instead.
+                (0, _devvalidationworkerpool.mirrorModuleStateToDevValidationWorker)({
+                    type: 'invalidate',
+                    filePaths: manifestPaths,
+                    evictModules: false
                 });
+                notifyServerComponentChanges();
             }
         });
     }