@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/server/mcp/tools/utils/format-errors.js

@@ -36,13 +36,15 @@ async function resolveStackFrames(request) {
     }
     return stackFrameResolver(request);
 }
-const formatStackFrame = (frame)=>{
-    const file = frame.file || '<unknown>';
-    const method = frame.methodName || '<anonymous>';
-    const { line1: line, column1: column } = frame;
-    return line && column ? `  at ${method} (${file}:${line}:${column})` : line ? `  at ${method} (${file}:${line})` : `  at ${method} (${file})`;
+const formatStackFrameToObject = (frame)=>{
+    return {
+        file: frame.file || '<unknown>',
+        methodName: frame.methodName || '<anonymous>',
+        line: frame.line1,
+        column: frame.column1
+    };
 };
-const formatErrorFrames = async (frames, context)=>{
+const resolveErrorFrames = async (frames, context)=>{
     try {
         const resolvedFrames = await resolveStackFrames({
             frames: frames.map((frame)=>({
@@ -59,89 +61,77 @@ const formatErrorFrames = async (frames, context)=>{
         return resolvedFrames.filter((resolvedFrame)=>{
             var _resolvedFrame_value_originalStackFrame;
             return !(resolvedFrame.status === 'fulfilled' && ((_resolvedFrame_value_originalStackFrame = resolvedFrame.value.originalStackFrame) == null ? void 0 : _resolvedFrame_value_originalStackFrame.ignored));
-        }).map((resolvedFrame, j)=>resolvedFrame.status === 'fulfilled' && resolvedFrame.value.originalStackFrame ? formatStackFrame(resolvedFrame.value.originalStackFrame) : formatStackFrame(frames[j])).join('\n') + '\n';
+        }).map((resolvedFrame, j)=>resolvedFrame.status === 'fulfilled' && resolvedFrame.value.originalStackFrame ? formatStackFrameToObject(resolvedFrame.value.originalStackFrame) : formatStackFrameToObject(frames[j]));
     } catch  {
-        return frames.map(formatStackFrame).join('\n') + '\n';
+        return frames.map(formatStackFrameToObject);
     }
 };
-async function formatRuntimeError(errors, isAppDirectory) {
-    const formatError = async (error, index)=>{
+async function formatRuntimeErrorsToObjects(errors, isAppDirectory) {
+    const formattedErrors = [];
+    for (const error of errors){
         var _error_error, _error_error1, _error_frames;
-        const errorHeader = `\n#### Error ${index + 1} (Type: ${error.type})\n\n`;
         const errorName = ((_error_error = error.error) == null ? void 0 : _error_error.name) || 'Error';
         const errorMsg = ((_error_error1 = error.error) == null ? void 0 : _error_error1.message) || 'Unknown error';
-        const errorMessage = `**${errorName}**: ${errorMsg}\n\n`;
-        if (!((_error_frames = error.frames) == null ? void 0 : _error_frames.length)) {
-            var _error_error2;
-            const stack = ((_error_error2 = error.error) == null ? void 0 : _error_error2.stack) || '';
-            return errorHeader + errorMessage + (stack ? `\`\`\`\n${stack}\n\`\`\`\n` : '');
+        let stack = [];
+        if ((_error_frames = error.frames) == null ? void 0 : _error_frames.length) {
+            const errorSource = (0, _errorsource.getErrorSource)(error.error);
+            stack = await resolveErrorFrames(error.frames, {
+                isServer: errorSource === 'server',
+                isEdgeServer: errorSource === 'edge-server',
+                isAppDirectory
+            });
         }
-        const errorSource = (0, _errorsource.getErrorSource)(error.error);
-        const frames = await formatErrorFrames(error.frames, {
-            isServer: errorSource === 'server',
-            isEdgeServer: errorSource === 'edge-server',
-            isAppDirectory
+        formattedErrors.push({
+            type: error.type,
+            errorName,
+            message: errorMsg,
+            stack
         });
-        return errorHeader + errorMessage + `\`\`\`\n${frames}\`\`\`\n`;
-    };
-    const formattedErrors = await Promise.all(errors.map(formatError));
-    return '### Runtime Errors\n' + formattedErrors.join('\n---\n');
+    }
+    return formattedErrors;
 }
 async function formatErrors(errorsByUrl, nextInstanceErrors = {
     nextConfig: []
 }) {
-    let output = '';
+    const output = {
+        configErrors: [],
+        sessionErrors: []
+    };
     // Format Next.js instance errors first (e.g., next.config.js errors)
-    if (nextInstanceErrors.nextConfig.length > 0) {
-        output += `# Next.js Configuration Errors\n\n`;
-        output += `**${nextInstanceErrors.nextConfig.length} error(s) found in next.config**\n\n`;
-        nextInstanceErrors.nextConfig.forEach((error, index)=>{
-            output += `## Error ${index + 1}\n\n`;
-            output += '```\n';
-            if (error instanceof Error) {
-                output += `${error.name}: ${error.message}\n`;
-                if (error.stack) {
-                    output += error.stack;
-                }
-            } else {
-                output += String(error);
-            }
-            output += '\n```\n\n';
-        });
-        output += '---\n\n';
+    for (const error of nextInstanceErrors.nextConfig){
+        if (error instanceof Error) {
+            output.configErrors.push({
+                name: error.name,
+                message: error.message,
+                stack: error.stack || null
+            });
+        } else {
+            output.configErrors.push({
+                name: 'Error',
+                message: String(error),
+                stack: null
+            });
+        }
     }
     // Format browser session errors
-    if (errorsByUrl.size > 0) {
-        output += `# Found errors in ${errorsByUrl.size} browser session(s)\n\n`;
-        for (const [url, overlayState] of errorsByUrl){
-            const totalErrorCount = overlayState.errors.length + (overlayState.buildError ? 1 : 0);
-            if (totalErrorCount === 0) continue;
-            let displayUrl = url;
-            try {
-                const urlObj = new URL(url);
-                displayUrl = urlObj.pathname + urlObj.search + urlObj.hash;
-            } catch  {
-            // If URL parsing fails, use the original URL
-            }
-            output += `## Session: ${displayUrl}\n\n`;
-            output += `**${totalErrorCount} error(s) found**\n\n`;
-            // Build errors
-            if (overlayState.buildError) {
-                output += '### Build Error\n\n';
-                output += '```\n';
-                output += overlayState.buildError;
-                output += '\n```\n\n';
-            }
-            // Runtime errors with source-mapped stack traces
-            if (overlayState.errors.length > 0) {
-                const runtimeErrors = await formatRuntimeError(overlayState.errors, overlayState.routerType === 'app');
-                output += runtimeErrors;
-                output += '\n';
-            }
-            output += '---\n\n';
+    for (const [url, overlayState] of errorsByUrl){
+        const totalErrorCount = overlayState.errors.length + (overlayState.buildError ? 1 : 0);
+        if (totalErrorCount === 0) continue;
+        let displayUrl = url;
+        try {
+            const urlObj = new URL(url);
+            displayUrl = urlObj.pathname + urlObj.search + urlObj.hash;
+        } catch  {
+        // If URL parsing fails, use the original URL
         }
+        const runtimeErrors = await formatRuntimeErrorsToObjects(overlayState.errors, overlayState.routerType === 'app');
+        output.sessionErrors.push({
+            url: displayUrl,
+            buildError: overlayState.buildError || null,
+            runtimeErrors
+        });
     }
-    return output.trim();
+    return output;
 }
 
 //# sourceMappingURL=format-errors.js.map

package/standalone/node_modules/next/dist/server/next-server.js

@@ -55,19 +55,19 @@ const _modulerender = require("./route-modules/app-page/module.render");
 const _modulerender1 = require("./route-modules/pages/module.render");
 const _interopdefault = require("../lib/interop-default");
 const _formatdynamicimportpath = require("../lib/format-dynamic-import-path");
-const _generateinterceptionroutesrewrites = require("../lib/generate-interception-routes-rewrites");
+const _isinterceptionrouterewrite = require("../lib/is-interception-route-rewrite");
 const _routekind = require("./route-kind");
 const _invarianterror = require("../shared/lib/invariant-error");
 const _awaiter = require("./after/awaiter");
 const _asynccallbackset = require("./lib/async-callback-set");
 const _handlers = require("./use-cache/handlers");
 const _staticenv = require("../lib/static-env");
-const _ispostpone = require("./lib/router-utils/is-postpone");
 const _nodemoduleloader = require("./lib/module-loader/node-module-loader");
 const _nofallbackerrorexternal = require("../shared/lib/no-fallback-error.external");
 const _instrumentationglobalsexternal = require("./lib/router-utils/instrumentation-globals.external");
 const _routerservercontext = require("./lib/router-utils/router-server-context");
 const _globalbehaviors = require("./node-environment-extensions/global-behaviors");
+const _processerrorhandlers = require("./node-environment-extensions/process-error-handlers");
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
@@ -146,81 +146,6 @@ function getMiddlewareMatcher(info) {
     MiddlewareMatcherCache.set(info, matcher);
     return matcher;
 }
-function installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListeners) {
-    // The conventional wisdom of Node.js and other runtimes is to treat
-    // unhandled errors as fatal and exit the process.
-    //
-    // But Next.js is not a generic JS runtime — it's a specialized runtime for
-    // React Server Components.
-    //
-    // Many unhandled rejections are due to the late-awaiting pattern for
-    // prefetching data. In Next.js it's OK to call an async function without
-    // immediately awaiting it, to start the request as soon as possible
-    // without blocking unncessarily on the result. These can end up
-    // triggering an "unhandledRejection" if it later turns out that the
-    // data is not needed to render the page. Example:
-    //
-    //     const promise = fetchData()
-    //     const shouldShow = await checkCondition()
-    //     if (shouldShow) {
-    //       return <Component promise={promise} />
-    //     }
-    //
-    // In this example, `fetchData` is called immediately to start the request
-    // as soon as possible, but if `shouldShow` is false, then it will be
-    // discarded without unwrapping its result. If it errors, it will trigger
-    // an "unhandledRejection" event.
-    //
-    // Ideally, we would suppress these rejections completely without warning,
-    // because we don't consider them real errors. (TODO: Currently we do warn.)
-    //
-    // But regardless of whether we do or don't warn, we definitely shouldn't
-    // crash the entire process.
-    //
-    // Even a "legit" unhandled error unrelated to prefetching shouldn't
-    // prevent the rest of the page from rendering.
-    //
-    // So, we're going to intentionally override the default error handling
-    // behavior of the outer JS runtime to be more forgiving
-    // Remove any existing "unhandledRejection" and "uncaughtException" handlers.
-    // This is gated behind an experimental flag until we've considered the impact
-    // in various deployment environments. It's possible this may always need to
-    // be configurable.
-    if (shouldRemoveUncaughtErrorAndRejectionListeners) {
-        process.removeAllListeners('uncaughtException');
-        process.removeAllListeners('unhandledRejection');
-    }
-    // Install a new handler to prevent the process from crashing.
-    process.on('unhandledRejection', (reason)=>{
-        if ((0, _ispostpone.isPostpone)(reason)) {
-            // React postpones that are unhandled might end up logged here but they're
-            // not really errors. They're just part of rendering.
-            return;
-        }
-        // Immediately log the error.
-        // TODO: Ideally, if we knew that this error was triggered by application
-        // code, we would suppress it entirely without logging. We can't reliably
-        // detect all of these, but when cacheComponents is enabled, we could suppress
-        // at least some of them by waiting to log the error until after all in-
-        // progress renders have completed. Then, only log errors for which there
-        // was not a corresponding "rejectionHandled" event.
-        console.error(reason);
-    });
-    process.on('rejectionHandled', ()=>{
-    // TODO: See note in the unhandledRejection handler above. In the future,
-    // we may use the "rejectionHandled" event to de-queue an error from
-    // being logged.
-    });
-    // Unhandled exceptions are errors triggered by non-async functions, so this
-    // is unrelated to the late-awaiting pattern. However, for similar reasons,
-    // we still shouldn't crash the process. Just log it.
-    process.on('uncaughtException', (reason)=>{
-        if ((0, _ispostpone.isPostpone)(reason)) {
-            return;
-        }
-        console.error(reason);
-    });
-}
 class NextNodeServer extends _baseserver.default {
     constructor(options){
         var _options_conf_experimental_sri, _options_conf_experimental, _options_conf_experimental1;
@@ -240,9 +165,26 @@ class NextNodeServer extends _baseserver.default {
             // the `else` branch is needed for tree-shaking
             } else {
                 const { ImageOptimizerCache } = require('./image-optimizer');
+                // Load custom cache handler if configured and opt-in via images.customCacheHandler
+                // Cache the handler instance to preserve state across requests
+                if (!this.imageCacheHandler && this.nextConfig.images.customCacheHandler) {
+                    const { cacheHandler } = this.nextConfig;
+                    if (cacheHandler) {
+                        const CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+                        this.imageCacheHandler = new CacheHandler({
+                            dev: !!this.dev,
+                            flushToDisk: this.nextConfig.experimental.isrFlushToDisk,
+                            serverDistDir: this.serverDistDir,
+                            maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                            revalidatedTags: [],
+                            _requestHeaders: {}
+                        });
+                    }
+                }
                 const imageOptimizerCache = new ImageOptimizerCache({
                     distDir: this.distDir,
-                    nextConfig: this.nextConfig
+                    nextConfig: this.nextConfig,
+                    cacheHandler: this.imageCacheHandler
                 });
                 const { sendResponse, ImageError } = require('./image-optimizer');
                 if (!this.imageResponseCache) {
@@ -257,7 +199,7 @@ class NextNodeServer extends _baseserver.default {
                     await this.render404(req, res);
                     return true;
                 }
-                const paramsResult = ImageOptimizerCache.validateParams(req.originalRequest, parsedUrl.query, this.nextConfig, !!this.renderOpts.dev);
+                const paramsResult = ImageOptimizerCache.validateParams(req.originalRequest, parsedUrl.query, this.nextConfig, !!this.dev);
                 if ('errorMessage' in paramsResult) {
                     res.statusCode = 400;
                     res.body(paramsResult.errorMessage).send();
@@ -294,7 +236,7 @@ class NextNodeServer extends _baseserver.default {
                             configurable: true
                         });
                     }
-                    sendResponse(req.originalRequest, res.originalResponse, paramsResult.href, cacheEntry.value.extension, cacheEntry.value.buffer, cacheEntry.value.etag, paramsResult.isStatic, cacheEntry.isMiss ? 'MISS' : cacheEntry.isStale ? 'STALE' : 'HIT', imagesConfig, ((_cacheEntry_cacheControl = cacheEntry.cacheControl) == null ? void 0 : _cacheEntry_cacheControl.revalidate) || 0, Boolean(this.renderOpts.dev));
+                    sendResponse(req.originalRequest, res.originalResponse, paramsResult.href, cacheEntry.value.extension, cacheEntry.value.buffer, cacheEntry.value.etag, paramsResult.isStatic, cacheEntry.isMiss ? 'MISS' : cacheEntry.isStale ? 'STALE' : 'HIT', imagesConfig, ((_cacheEntry_cacheControl = cacheEntry.cacheControl) == null ? void 0 : _cacheEntry_cacheControl.revalidate) || 0, Boolean(this.dev));
                     return true;
                 } catch (err) {
                     if (err instanceof ImageError) {
@@ -330,6 +272,7 @@ class NextNodeServer extends _baseserver.default {
                 };
             }
             _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir].nextConfig = this.nextConfig;
+            _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir].isWrappedByNextServer = true;
             try {
                 var _this_i18nProvider;
                 // next.js core assumes page path without trailing slash
@@ -399,7 +342,7 @@ class NextNodeServer extends _baseserver.default {
                     throw err;
                 }
                 try {
-                    if (this.renderOpts.dev) {
+                    if (this.dev) {
                         const { formatServerError } = require('../lib/format-server-error');
                         formatServerError(err);
                         this.logErrorWithOriginalStack(err);
@@ -497,6 +440,9 @@ class NextNodeServer extends _baseserver.default {
             return result.finished;
         };
         (0, _globalbehaviors.installGlobalBehaviors)(this.nextConfig);
+        // Load prefetch hints from the build output. This must happen before
+        // any render to ensure segment inlining decisions are available.
+        this.renderOpts.prefetchHints = this.getPrefetchHints();
         const isDev = options.dev ?? false;
         this.isDev = isDev;
         this.sriEnabled = Boolean((_options_conf_experimental = options.conf.experimental) == null ? void 0 : (_options_conf_experimental_sri = _options_conf_experimental.sri) == null ? void 0 : _options_conf_experimental_sri.algorithm);
@@ -551,10 +497,12 @@ class NextNodeServer extends _baseserver.default {
         // when using compile mode static env isn't inlined so we
         // need to populate in normal runtime env
         if (this.renderOpts.isExperimentalCompile) {
-            (0, _staticenv.populateStaticEnv)(this.nextConfig, this.renderOpts.deploymentId || '');
+            // immutableAssetToken only works with Turbopack, and `isExperimentalCompile` isn't supported
+            // with that anyway, so we can assign immutableAssetToken to deploymentId here
+            (0, _staticenv.populateStaticEnv)(this.nextConfig, this.deploymentId || '');
         }
         const shouldRemoveUncaughtErrorAndRejectionListeners = Boolean((_options_conf_experimental1 = options.conf.experimental) == null ? void 0 : _options_conf_experimental1.removeUncaughtErrorAndRejectionListeners);
-        installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListeners);
+        (0, _processerrorhandlers.installProcessErrorHandlers)(shouldRemoveUncaughtErrorAndRejectionListeners);
     }
     async unstable_preloadEntries() {
         // Ensure prepare process will be finished before preloading entries.
@@ -641,7 +589,7 @@ class NextNodeServer extends _baseserver.default {
         }
     }
     async getIncrementalCache({ requestHeaders }) {
-        const dev = !!this.renderOpts.dev;
+        const dev = !!this.dev;
         let CacheHandler;
         const { cacheHandler } = this.nextConfig;
         if (cacheHandler) {
@@ -681,7 +629,7 @@ class NextNodeServer extends _baseserver.default {
     getinterceptionRoutePatterns() {
         if (!this.enabledDirectories.app) return [];
         const routesManifest = this.getRoutesManifest();
-        return (routesManifest == null ? void 0 : routesManifest.rewrites.beforeFiles.filter(_generateinterceptionroutesrewrites.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))) ?? [];
+        return (routesManifest == null ? void 0 : routesManifest.rewrites.beforeFiles.filter(_isinterceptionrouterewrite.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))) ?? [];
     }
     async hasPage(pathname) {
         var _this_nextConfig_i18n;
@@ -769,14 +717,17 @@ class NextNodeServer extends _baseserver.default {
                 return (0, _modulerender.lazyRenderAppPage)(req, res, pathname, query, // This code path does not service revalidations for unknown param
                 // shells. As a result, we don't need to pass in the unknown params.
                 null, renderOpts, this.getServerComponentsHmrCache(), {
-                    buildId: this.buildId
+                    buildId: this.buildId,
+                    deploymentId: this.deploymentId,
+                    clientAssetToken: this.nextConfig.experimental.immutableAssetToken ?? this.deploymentId
                 });
             } else {
                 // TODO: re-enable this once we've refactored to use implicit matches
                 // throw new Error('Invariant: render should have used routeModule')
                 return (0, _modulerender1.lazyRenderPagesPage)(req.originalRequest, res.originalResponse, pathname, query, renderOpts, {
                     buildId: this.buildId,
-                    deploymentId: this.renderOpts.deploymentId,
+                    deploymentId: this.deploymentId,
+                    clientAssetToken: this.nextConfig.experimental.immutableAssetToken ?? this.deploymentId,
                     customServer: this.serverOptions.customServer || undefined
                 }, {
                     isFallback: false,
@@ -813,10 +764,19 @@ class NextNodeServer extends _baseserver.default {
                 await this.routerServerHandler(newReq, newRes);
                 return;
             };
-            const { isAbsolute, href } = paramsResult;
-            const imageUpstream = isAbsolute ? await fetchExternalImage(href, this.nextConfig.images.dangerouslyAllowLocalIP, this.nextConfig.images.maximumResponseBody, this.nextConfig.images.maximumRedirects) : await fetchInternalImage(href, req.originalRequest, res.originalResponse, handleInternalReq);
+            let { href } = paramsResult;
+            if (process.env.__NEXT_TEST_MODE && process.env.IS_TURBOPACK_TEST && !paramsResult.isAbsolute) {
+                // Forward the dpl query param from the original /_next/image request to the
+                // internal static file request so that the static file validation in
+                // resolve-routes.ts can verify it.
+                const dpl = typeof req.url === 'string' ? new URL(req.url, 'http://n').searchParams.get('dpl') : undefined;
+                if (dpl) {
+                    href += `${href.includes('?') ? '&' : '?'}dpl=${dpl}`;
+                }
+            }
+            const imageUpstream = paramsResult.isAbsolute ? await fetchExternalImage(href, this.nextConfig.images.dangerouslyAllowLocalIP, this.nextConfig.images.maximumResponseBody, this.nextConfig.images.maximumRedirects) : await fetchInternalImage(href, req.originalRequest, res.originalResponse, handleInternalReq);
             return imageOptimizer(imageUpstream, paramsResult, this.nextConfig, {
-                isDev: this.renderOpts.dev,
+                isDev: this.dev,
                 previousCacheEntry
             });
         }
@@ -968,10 +928,10 @@ class NextNodeServer extends _baseserver.default {
         const handler = super.getRequestHandler();
         return (req, res, parsedUrl)=>handler(this.normalizeReq(req), this.normalizeRes(res), parsedUrl);
     }
-    async revalidate({ urlPath, revalidateHeaders, opts }) {
+    async revalidate({ urlPath, headers, opts }) {
         const mocked = (0, _mockrequest.createRequestResponseMocks)({
             url: urlPath,
-            headers: revalidateHeaders
+            headers
         });
         const handler = this.getRequestHandler();
         await handler(new _node.NodeNextRequest(mocked.req), new _node.NodeNextResponse(mocked.res));
@@ -994,7 +954,7 @@ class NextNodeServer extends _baseserver.default {
         const { req, res, query } = ctx;
         const is404 = res.statusCode === 404;
         if (is404 && this.enabledDirectories.app) {
-            if (this.renderOpts.dev) {
+            if (this.dev) {
                 await this.ensurePage({
                     page: _constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY,
                     clientOnly: false,
@@ -1106,8 +1066,8 @@ class NextNodeServer extends _baseserver.default {
         if (!process.env.NEXT_MINIMAL) {
             try {
                 var _functionsConfig_functions;
-                const functionsConfig = this.renderOpts.dev ? {} : require((0, _path.join)(/* turbopackIgnore: true */ this.distDir, 'server', _constants.FUNCTIONS_CONFIG_MANIFEST));
-                if (this.renderOpts.dev || (functionsConfig == null ? void 0 : (_functionsConfig_functions = functionsConfig.functions) == null ? void 0 : _functionsConfig_functions['/_middleware'])) {
+                const functionsConfig = this.dev ? {} : require((0, _path.join)(/* turbopackIgnore: true */ this.distDir, 'server', _constants.FUNCTIONS_CONFIG_MANIFEST));
+                if (this.dev || (functionsConfig == null ? void 0 : (_functionsConfig_functions = functionsConfig.functions) == null ? void 0 : _functionsConfig_functions['/_middleware'])) {
                     // if used with top level await, this will be a promise
                     return require((0, _path.join)(/* turbopackIgnore: true */ this.distDir, 'server', 'middleware.js'));
                 }
@@ -1251,10 +1211,11 @@ class NextNodeServer extends _baseserver.default {
                 edgeFunctionEntry: middlewareInfo,
                 request: requestData,
                 useCache: true,
-                onWarning: params.onWarning
+                onWarning: params.onWarning,
+                clientAssetToken: this.nextConfig.experimental.immutableAssetToken || this.deploymentId
             });
         }
-        if (!this.renderOpts.dev) {
+        if (!this.dev) {
             result.waitUntil.catch((error)=>{
                 console.error(`Uncaught: middleware waitUntil errored`, error);
             });
@@ -1286,6 +1247,14 @@ class NextNodeServer extends _baseserver.default {
         this._cachedPreviewManifest = (0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.PRERENDER_MANIFEST));
         return this._cachedPreviewManifest;
     }
+    getPrefetchHints() {
+        if (this._cachedPrefetchHints) {
+            return this._cachedPrefetchHints;
+        }
+        this._cachedPrefetchHints = (0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.SERVER_DIRECTORY, _constants.PREFETCH_HINTS), true, undefined, false, true // handleMissing: don't crash if the file doesn't exist
+        ) ?? {};
+        return this._cachedPrefetchHints;
+    }
     getRoutesManifest() {
         return (0, _tracer.getTracer)().trace(_constants1.NextNodeServerSpan.getRoutesManifest, ()=>(0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.ROUTES_MANIFEST)));
     }
@@ -1377,7 +1346,8 @@ class NextNodeServer extends _baseserver.default {
             onError: params.onError,
             onWarning: params.onWarning,
             incrementalCache: globalThis.__incrementalCache || (0, _requestmeta.getRequestMeta)(params.req, 'incrementalCache'),
-            serverComponentsHmrCache: (0, _requestmeta.getRequestMeta)(params.req, 'serverComponentsHmrCache')
+            serverComponentsHmrCache: (0, _requestmeta.getRequestMeta)(params.req, 'serverComponentsHmrCache'),
+            clientAssetToken: this.nextConfig.experimental.immutableAssetToken || this.deploymentId
         });
         if (result.fetchMetrics) {
             params.req.fetchMetrics = result.fetchMetrics;
@@ -1422,7 +1392,7 @@ class NextNodeServer extends _baseserver.default {
     async instrumentationOnRequestError(...args) {
         await super.instrumentationOnRequestError(...args);
         // For Node.js runtime production logs, in dev it will be overridden by next-dev-server
-        if (!this.renderOpts.dev) {
+        if (!this.dev) {
             const [err, , , silenceLog] = args;
             if (!silenceLog) {
                 this.logError(err);

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

@@ -290,6 +290,9 @@ class NextServer {
         return this.options.port;
     }
     async prepare() {
+        if (this.options.dev) {
+            process.env.__NEXT_DEV_SERVER = '1';
+        }
         const { getRequestHandlers } = require('./lib/start-server');
         let onDevServerCleanup;
         if (this.options.dev) {

package/standalone/node_modules/next/dist/server/node-environment-extensions/console-dim.external.js

@@ -8,10 +8,52 @@ Object.defineProperty(exports, "setAbortedLogsStyle", {
         return setAbortedLogsStyle;
     }
 });
+const _nodeinspector = /*#__PURE__*/ _interop_require_wildcard(require("node:inspector"));
 const _picocolors = require("../../lib/picocolors");
 const _consoleasyncstorageexternal = require("../app-render/console-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _runtimereactsexternal = require("../runtime-reacts.external");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- we may use later and want parity with the HIDDEN_STYLE value
 const DIMMED_STYLE = 'dimmed';
 const HIDDEN_STYLE = 'hidden';
@@ -115,6 +157,15 @@ function dimmedConsoleArgs(...inputArgs) {
     ];
 }
 function convertToDimmedArgs(methodName, args) {
+    // When the Node.js inspector is open (e.g. --inspect), skip dimming entirely.
+    // Dimming wraps arguments in a format string which defeats inspector
+    // affordances such as collapsible objects and clickable/linkified stack
+    // traces. Ideally we would only skip dimming when a debugger frontend is
+    // actually attached, but Node.js does not expose a synchronous API for that.
+    // Detecting would require async polling of the /json/list HTTP endpoint.
+    if (_nodeinspector.url() !== undefined) {
+        return args;
+    }
     switch(methodName){
         case 'dir':
         case 'dirxml':
@@ -186,13 +237,16 @@ function patchConsoleMethod(methodName) {
                 // to create a cache scope for arbitrary computation and can move over to cacheSignal exclusively.
                 // fallthrough
                 case 'prerender-client':
-                    // This is a react-dom/server render and won't have a cacheSignal until React adds this for the client world.
-                    const renderSignal = workUnitStore.renderSignal;
-                    if (renderSignal.aborted) {
-                        if (currentAbortedLogsStyle === HIDDEN_STYLE) {
-                            return;
+                case 'validation-client':
+                    {
+                        // This is a react-dom/server render and won't have a cacheSignal until React adds this for the client world.
+                        const renderSignal = workUnitStore.renderSignal;
+                        if (renderSignal.aborted) {
+                            if (currentAbortedLogsStyle === HIDDEN_STYLE) {
+                                return;
+                            }
+                            return applyWithDimming.call(this, consoleStore, originalMethod, methodName, args);
                         }
-                        return applyWithDimming.call(this, consoleStore, originalMethod, methodName, args);
                     }
                 // intentional fallthrough
                 case 'prerender-legacy':
@@ -201,6 +255,7 @@ function patchConsoleMethod(methodName) {
                 case 'unstable-cache':
                 case 'private-cache':
                 case 'request':
+                case 'generate-static-params':
                 case undefined:
                     if ((consoleStore == null ? void 0 : consoleStore.dim) === true) {
                         return applyWithDimming.call(this, consoleStore, originalMethod, methodName, args);

package/standalone/node_modules/next/dist/server/node-environment-extensions/date.js

@@ -12,11 +12,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 function createNow(originalNow) {
     return ({
         now: function now() {
-            (0, _utils.io)('`Date.now()`', 'time');
+            (0, _ioutils.io)('`Date.now()`', 'time');
             return originalNow();
         }
     })['now'.slice()].bind(null);
@@ -29,11 +29,11 @@ function createDate(originalConstructor) {
     const newConstructor = Object.defineProperties(// Ideally this should not minify the name.
     function Date1() {
         if (new.target === undefined) {
-            (0, _utils.io)('`Date()`', 'time');
+            (0, _ioutils.io)('`Date()`', 'time');
             return apply(originalConstructor, undefined, arguments);
         }
         if (arguments.length === 0) {
-            (0, _utils.io)('`new Date()`', 'time');
+            (0, _ioutils.io)('`new Date()`', 'time');
         }
         return construct(originalConstructor, arguments, new.target);
     }, properties);