@semiont/frontend 0.3.3 → 0.3.4

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

@@ -34,6 +34,7 @@ const _messages = require("./messages");
 const _encryptionutilsserver = require("../app-render/encryption-utils-server");
 const _apppageroutedefinition = require("../route-definitions/app-page-route-definition");
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _entries = require("../../build/entries");
 const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
 const _patcherrorinspect = require("../patch-error-inspect");
 const _getnexterrorfeedbackmiddleware = require("../../next-devtools/server/get-next-error-feedback-middleware");
@@ -43,7 +44,8 @@ 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 _utils3 = require("../../build/utils");
+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 _devtoolsconfigmiddleware = require("../../next-devtools/server/devtools-config-middleware");
@@ -108,6 +110,82 @@ 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;
+        }
+        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') {
+                    continue;
+                }
+                if (typeof __turbopack_server_hmr_apply__ === 'function') {
+                    const applied = __turbopack_server_hmr_apply__(update);
+                    if (!applied) {
+                        await clear();
+                    }
+                }
+            }
+        })().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
+    ;
+    (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);
+                    }
+                }
+            }
+        } 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) {
@@ -136,12 +214,21 @@ function getSourceMapFromTurbopack(project, projectRoot, sourceURL) {
         return payload;
     }
 }
-async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetch, lockfile) {
+async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetch, lockfile, serverFastRefresh) {
     var _opts_nextConfig_turbopack, _nextConfig_watchOptions, _opts_nextConfig_experimental;
     const dev = true;
     const buildId = 'development';
     const { nextConfig, dir: projectPath } = opts;
     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
+        });
+    }
     // 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) {
@@ -153,7 +240,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.1.6"
+        version: "16.2.0"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -172,7 +259,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     if (nextConfig.experimental.clientRouterFilter) {
     // TODO this need to be set correctly for filesystem cache to work
     }
-    const supportedBrowsers = (0, _utils3.getSupportedBrowsers)(projectPath, dev);
+    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;
     const project = await bindings.turbo.createProject({
@@ -201,23 +288,31 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         }),
         buildId,
         encryptionKey,
-        previewProps: opts.fsChecker.prerenderManifest.preview,
+        previewProps: opts.fsChecker.previewProps,
         browserslistQuery: supportedBrowsers.join(', '),
         noMangling: false,
         writeRoutesHashesManifest: false,
-        currentNodeJsVersion
+        currentNodeJsVersion,
+        isPersistentCachingEnabled: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
+        nextVersion: "16.2.0",
+        serverHmr: serverFastRefresh
     }, {
-        persistentCaching: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
         memoryLimit: (_opts_nextConfig_experimental = opts.nextConfig.experimental) == null ? void 0 : _opts_nextConfig_experimental.turbopackMemoryLimit,
         isShortSession: false
     });
     (0, _compilationevents.backgroundLogCompilationEvents)(project, {
         eventTypes: [
             'StartupCacheInvalidationEvent',
-            'TimingEvent'
-        ]
+            'TimingEvent',
+            'SlowFilesystemEvent',
+            'TraceEvent'
+        ],
+        parentSpan: hotReloaderSpan
     });
     (0, _patcherrorinspect.setBundlerFindSourceMapImplementation)(getSourceMapFromTurbopack.bind(null, project, projectPath));
+    // 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);
         await project.onExit();
@@ -241,7 +336,9 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     const manifestLoader = new _manifestloader.TurbopackManifestLoader({
         buildId,
         distDir,
-        encryptionKey
+        encryptionKey,
+        dev: true,
+        sriEnabled: false
     });
     // Dev specific
     const changeSubscriptions = new Map();
@@ -250,7 +347,64 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     let currentEntriesHandlingResolve;
     let currentEntriesHandling = new Promise((resolve)=>currentEntriesHandlingResolve = resolve);
     const assetMapper = new _turbopackutils.AssetMapper();
+    // Deferred entries state management
+    const deferredEntriesConfig = nextConfig.experimental.deferredEntries;
+    const hasDeferredEntriesConfig = deferredEntriesConfig && deferredEntriesConfig.length > 0;
+    let onBeforeDeferredEntriesCalled = false;
+    let onBeforeDeferredEntriesPromise = null;
+    // Track non-deferred entries that are currently being built
+    const nonDeferredBuildingEntries = new Set();
+    // Function to wait for all non-deferred entries to be built
+    async function waitForNonDeferredEntries() {
+        return new Promise((resolve)=>{
+            const checkEntries = ()=>{
+                // Check if there are any non-deferred entries that are still building
+                if (nonDeferredBuildingEntries.size === 0) {
+                    resolve();
+                } else {
+                    // Check again after a short delay
+                    setTimeout(checkEntries, 100);
+                }
+            };
+            checkEntries();
+        });
+    }
+    // Function to handle deferred entry processing
+    async function processDeferredEntry() {
+        if (!hasDeferredEntriesConfig) return;
+        // Wait for all non-deferred entries to be built
+        await waitForNonDeferredEntries();
+        // Call the onBeforeDeferredEntries callback once
+        if (!onBeforeDeferredEntriesCalled) {
+            onBeforeDeferredEntriesCalled = true;
+            if (nextConfig.experimental.onBeforeDeferredEntries) {
+                if (!onBeforeDeferredEntriesPromise) {
+                    onBeforeDeferredEntriesPromise = nextConfig.experimental.onBeforeDeferredEntries();
+                }
+                await onBeforeDeferredEntriesPromise;
+            }
+        } else if (onBeforeDeferredEntriesPromise) {
+            // Wait for any in-progress callback
+            await onBeforeDeferredEntriesPromise;
+        }
+    }
+    // Track whether HMR is pending - used to call callback once after HMR settles
+    let hmrPendingDeferredCallback = false;
+    // Debounced function to call onBeforeDeferredEntries after HMR
+    // This prevents rapid-fire calls when turbopack fires many update events
+    // Use 500ms debounce to ensure all rapid updates are batched together
+    const callOnBeforeDeferredEntriesAfterHMR = (0, _utils1.debounce)(()=>{
+        // Only call if HMR triggered a need for the callback
+        if (hasDeferredEntriesConfig && hmrPendingDeferredCallback) {
+            hmrPendingDeferredCallback = false;
+            onBeforeDeferredEntriesCalled = true;
+            if (nextConfig.experimental.onBeforeDeferredEntries) {
+                onBeforeDeferredEntriesPromise = nextConfig.experimental.onBeforeDeferredEntries();
+            }
+        }
+    }, 500);
     function clearRequireCache(key, writtenEndpoint, { force } = {}) {
+        var _currentEntrypoints_app_get;
         if (force) {
             for (const { path, contentHash } of writtenEndpoint.serverPaths){
                 // We ignore source maps
@@ -285,17 +439,42 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 return false;
             }
         }
-        resetFetch();
-        // Not available in:
-        // - Pages Router (no server-side HMR)
-        // - Edge Runtime (uses browser runtime which already disposes chunks individually)
-        if (typeof __next__clear_chunk_cache__ === 'function') {
-            __next__clear_chunk_cache__();
-        }
         const serverPaths = writtenEndpoint.serverPaths.map(({ path: p })=>(0, _path.join)(distDir, p));
+        const { type: entryType, page: entryPage } = (0, _entrykey.splitEntryKey)(key);
+        const isAppPage = entryType === 'app' && ((_currentEntrypoints_app_get = currentEntrypoints.app.get(entryPage)) == null ? void 0 : _currentEntrypoints_app_get.type) === 'app-page';
+        // Server HMR only applies to app router pages since these use the Turbopack runtime.
+        // Currently, this is only app router pages.
+        //
+        // This excludes:
+        //   - Pages Router pages
+        //   - Edge routes
+        //   - Middleware
+        //   - App Router route handlers (route.ts)
+        const usesServerHmr = serverFastRefresh && isAppPage && writtenEndpoint.type !== 'edge';
+        const filesToDelete = [];
         for (const file of serverPaths){
             (0, _renderserver.clearModuleContext)(file);
-            (0, _requirecache.deleteCache)(file);
+            const relativePath = (0, _path.relative)(distDir, file);
+            if (// For Pages Router, edge routes, middleware, and manifest files
+            // (e.g., *_client-reference-manifest.js): clear the sharedCache in
+            // evalManifest(), Node.js require.cache, and edge runtime module contexts.
+            force || !usesServerHmr || !(serverHmrSubscriptions == null ? void 0 : serverHmrSubscriptions.has(relativePath))) {
+                filesToDelete.push(file);
+            }
+        }
+        (0, _requirecache.deleteCache)(filesToDelete);
+        // Reset the fetch patch so patchFetch() can re-wrap on the next request.
+        if (serverPaths.length > 0) {
+            resetFetch();
+        }
+        // Clear Turbopack's chunk-loading cache so chunks are re-required from disk on
+        // the next request.
+        //
+        // For App Router with server HMR, this is normally skipped as server HMR
+        // manages module updates in-place. However, it *is* required when force is `true`
+        // (like for .env file or tsconfig changes).
+        if ((!usesServerHmr || force) && typeof __next__clear_chunk_cache__ === 'function') {
+            __next__clear_chunk_cache__();
         }
         return true;
     }
@@ -326,6 +505,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             }
         };
     };
+    let serverHmrSubscriptions;
     let hmrEventHappened = false;
     let hmrHash = 0;
     const clientsWithoutHtmlRequestId = new Set();
@@ -402,7 +582,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         hmrEventHappened = true;
         sendEnqueuedMessagesDebounce();
     }
-    async function subscribeToChanges(key, includeIssues, endpoint, createMessage, onError) {
+    async function subscribeToClientChanges(key, includeIssues, endpoint, createMessage, onError) {
         if (changeSubscriptions.has(key)) {
             return;
         }
@@ -429,7 +609,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         }
         changeSubscriptions.delete(key);
     }
-    async function unsubscribeFromChanges(key) {
+    async function unsubscribeFromClientChanges(key) {
         const subscription = await changeSubscriptions.get(key);
         if (subscription) {
             await (subscription.return == null ? void 0 : subscription.return.call(subscription));
@@ -437,7 +617,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         }
         currentEntryIssues.delete(key);
     }
-    async function subscribeToHmrEvents(client, id) {
+    async function subscribeToClientHmrEvents(client, id) {
         const key = (0, _entrykey.getEntryKey)('assets', 'client', id);
         if (!(0, _turbopackutils.hasEntrypointForKey)(currentEntrypoints, key, assetMapper)) {
             // maybe throw an error / force the client to reload?
@@ -447,7 +627,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         if (!state || state.subscriptions.has(id)) {
             return;
         }
-        const subscription = project.hmrEvents(id);
+        const subscription = project.hmrEvents(id, _swc.HmrTarget.Client);
         state.subscriptions.set(id, subscription);
         // The subscription will always emit once, which is the initial
         // computation. This is not a change, so swallow it.
@@ -473,7 +653,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             return;
         }
     }
-    function unsubscribeFromHmrEvents(client, id) {
+    function unsubscribeFromClientHmrEvents(client, id) {
         const state = clientStates.get(client);
         if (!state) {
             return;
@@ -493,7 +673,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             (0, _turbopackutils.processTopLevelIssues)(currentTopLevelIssues, entrypoints);
             // Certain crtical issues prevent any entrypoints from being constructed so return early
             if (!('routes' in entrypoints)) {
-                (0, _utils3.printBuildErrors)(entrypoints, true);
+                (0, _printbuilderrors.printBuildErrors)(entrypoints, true);
                 currentEntriesHandlingResolve();
                 currentEntriesHandlingResolve = undefined;
                 continue;
@@ -535,9 +715,9 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         propagateServerField: _setupdevbundler.propagateServerField.bind(null, opts),
                         sendHmr,
                         startBuilding,
-                        subscribeToChanges,
-                        unsubscribeFromChanges,
-                        unsubscribeFromHmrEvents
+                        subscribeToChanges: subscribeToClientChanges,
+                        unsubscribeFromChanges: unsubscribeFromClientChanges,
+                        unsubscribeFromHmrEvents: unsubscribeFromClientHmrEvents
                     }
                 }
             });
@@ -785,7 +965,8 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             break;
                         case 'browser-logs':
                             {
-                                if (nextConfig.experimental.browserDebugInfoInTerminal) {
+                                const browserToTerminalConfig = nextConfig.logging && nextConfig.logging.browserToTerminal;
+                                if (browserToTerminalConfig) {
                                     await (0, _receivelogs.receiveBrowserLogsTurbopack)({
                                         entries: parsedData.entries,
                                         router: parsedData.router,
@@ -793,7 +974,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                                         project,
                                         projectPath,
                                         distDir,
-                                        config: nextConfig.experimental.browserDebugInfoInTerminal
+                                        config: browserToTerminalConfig
                                     });
                                 }
                                 break;
@@ -831,10 +1012,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     // Turbopack messages
                     switch(parsedData.type){
                         case 'turbopack-subscribe':
-                            subscribeToHmrEvents(client, parsedData.path);
+                            subscribeToClientHmrEvents(client, parsedData.path);
                             break;
                         case 'turbopack-unsubscribe':
-                            unsubscribeFromHmrEvents(client, parsedData.path);
+                            unsubscribeFromClientHmrEvents(client, parsedData.path);
                             break;
                         default:
                             if (!parsedData.event) {
@@ -1060,6 +1241,16 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 if (!appPaths && definition && (0, _apppageroutedefinition.isAppPageRouteDefinition)(definition)) {
                     appPaths = definition.appPaths;
                 }
+                // Check if this is a deferred entry and wait for non-deferred entries first
+                if (hasDeferredEntriesConfig) {
+                    const isDeferred = (0, _entries.isDeferredEntry)(routeDef.page, deferredEntriesConfig);
+                    if (isDeferred) {
+                        await processDeferredEntry();
+                    } else {
+                        // Track non-deferred entry as building
+                        nonDeferredBuildingEntries.add(routeDef.page);
+                    }
+                }
                 let page = routeDef.page;
                 if (appPaths) {
                     const normalizedPage = (0, _apppaths.normalizeAppPath)(page);
@@ -1080,7 +1271,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             productionRewrites: undefined,
                             logErrors: true,
                             hooks: {
-                                subscribeToChanges,
+                                subscribeToChanges: subscribeToClientChanges,
                                 handleWrittenEndpoint: (id, result, forceDeleteCache)=>{
                                     currentWrittenEntrypoints.set(id, result);
                                     assetMapper.setPathsForKey(id, result.clientPaths);
@@ -1134,7 +1325,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         productionRewrites: undefined,
                         logErrors: true,
                         hooks: {
-                            subscribeToChanges,
+                            subscribeToChanges: subscribeToClientChanges,
                             handleWrittenEndpoint: (id, result, forceDeleteCache)=>{
                                 currentWrittenEntrypoints.set(id, result);
                                 assetMapper.setPathsForKey(id, result.clientPaths);
@@ -1146,6 +1337,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     });
                 } finally{
                     finishBuilding();
+                    // Remove non-deferred entry from building set
+                    if (hasDeferredEntriesConfig) {
+                        nonDeferredBuildingEntries.delete(routeDef.page);
+                    }
                 }
             });
         },
@@ -1182,6 +1377,13 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         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
+                        if (hasDeferredEntriesConfig) {
+                            hmrPendingDeferredCallback = true;
+                            onBeforeDeferredEntriesCalled = false;
+                            onBeforeDeferredEntriesPromise = null;
+                        }
                         break;
                     }
                 case 'end':
@@ -1231,6 +1433,12 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             _log.event(`Compiled in ${timeMessage}`);
                             hmrEventHappened = 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
+                        if (hasDeferredEntriesConfig) {
+                            callOnBeforeDeferredEntriesAfterHMR();
+                        }
                         break;
                     }
                 default:
@@ -1241,6 +1449,29 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         console.error(err);
         process.exit(1);
     });
+    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));
+                (0, _requirecache.deleteCache)(chunkPaths);
+                // Clear Turbopack's runtime caches
+                if (typeof __next__clear_chunk_cache__ === 'function') {
+                    __next__clear_chunk_cache__();
+                }
+                // 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)
+                });
+            }
+        });
+    }
     return hotReloader;
 }
 

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

@@ -26,6 +26,7 @@ const _hotmiddleware = require("./hot-middleware");
 const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
 const _path = require("path");
 const _entries = require("../../build/entries");
+const _routediscovery = require("../../build/route-discovery");
 const _getstaticinfoincludinglayouts = require("../../build/get-static-info-including-layouts");
 const _output = require("../../build/output");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
@@ -233,7 +234,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "16.1.6"
+            version: "16.2.0"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.
@@ -462,7 +463,8 @@ class HotReloaderWebpack {
                             }
                         case 'browser-logs':
                             {
-                                if (this.config.experimental.browserDebugInfoInTerminal) {
+                                const browserToTerminalConfig = this.config.logging && this.config.logging.browserToTerminal;
+                                if (browserToTerminalConfig) {
                                     await (0, _receivelogs.receiveBrowserLogsWebpack)({
                                         entries: payload.entries,
                                         router: payload.router,
@@ -472,7 +474,7 @@ class HotReloaderWebpack {
                                         edgeServerStats: ()=>this.edgeServerStats,
                                         rootDirectory: this.dir,
                                         distDir: this.distDir,
-                                        config: this.config.experimental.browserDebugInfoInTerminal
+                                        config: browserToTerminalConfig
                                     });
                                 }
                                 break;
@@ -536,7 +538,7 @@ class HotReloaderWebpack {
                     (0, _findpagefile.findPageFile)(this.pagesDir, '/_app', pageExtensions, false),
                     (0, _findpagefile.findPageFile)(this.pagesDir, '/_document', pageExtensions, false)
                 ]));
-            this.pagesMapping = await webpackConfigSpan.traceChild('create-pages-mapping').traceAsyncFn(()=>(0, _entries.createPagesMapping)({
+            this.pagesMapping = await webpackConfigSpan.traceChild('create-pages-mapping').traceAsyncFn(()=>(0, _routediscovery.createPagesMapping)({
                     isDev: true,
                     pageExtensions: this.config.pageExtensions,
                     pagesType: _pagetypes.PAGE_TYPES.PAGES,
@@ -783,6 +785,7 @@ class HotReloaderWebpack {
                                 name: bundlePath,
                                 page,
                                 appPaths: entryData.appPaths,
+                                allNormalizedAppPaths: null,
                                 pagePath: _path.posix.join(_constants.APP_DIR_ALIAS, (0, _path.relative)(this.appDir, entryData.absolutePagePath).replace(/\\/g, '/')),
                                 appDir: this.appDir,
                                 pageExtensions: this.config.pageExtensions,
@@ -882,6 +885,7 @@ class HotReloaderWebpack {
                                     name: bundlePath,
                                     page,
                                     appPaths: entryData.appPaths,
+                                    allNormalizedAppPaths: null,
                                     pagePath,
                                     appDir: this.appDir,
                                     pageExtensions: this.config.pageExtensions,

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

@@ -24,6 +24,7 @@ const _durationtostring = require("../../build/duration-to-string");
 const _picocolors = require("../../lib/picocolors");
 const _url = require("../../lib/url");
 const _requestmeta = require("../request-meta");
+const _serveractionlogger = require("./server-action-logger");
 function ignoreLoggingIncomingRequests(request, loggingConfig) {
     var _loggingConfig_incomingRequests;
     // If it's boolean use the boolean value
@@ -42,6 +43,13 @@ function ignoreLoggingIncomingRequests(request, loggingConfig) {
 function logRequests(request, response, loggingConfig, requestStartTime, requestEndTime, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration) {
     if (!ignoreLoggingIncomingRequests(request, loggingConfig)) {
         logIncomingRequests(request, requestStartTime, requestEndTime, response.statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration);
+        // Log server action after the request log
+        const serverActionLog = (0, _requestmeta.getRequestMeta)(request, 'devServerActionLog');
+        if (serverActionLog) {
+            const argsStr = (0, _serveractionlogger.formatArgs)(serverActionLog.args);
+            process.stdout.write(`  └─ ƒ ${serverActionLog.functionName}(${argsStr}) in ${serverActionLog.duration}ms ${(0, _picocolors.dim)(serverActionLog.location)}\n`);
+            (0, _requestmeta.removeRequestMeta)(request, 'devServerActionLog');
+        }
     }
     if (request.fetchMetrics) {
         for (const fetchMetric of request.fetchMetrics){
@@ -71,7 +79,7 @@ function logIncomingRequests(request, requestStartTime, requestEndTime, statusCo
         }
         // Insert as the first item to be rendered in the list
         times.unshift([
-            'compile',
+            'next.js',
             frameworkTime
         ]);
         // Insert after compile, before render based on the execution order.
@@ -83,7 +91,7 @@ function logIncomingRequests(request, requestStartTime, requestEndTime, statusCo
             ]);
         }
         times.push([
-            'render',
+            'application-code',
             requestEndTime - devRequestTimingInternalsEnd
         ]);
     }