@evoscientist/webui 0.2.4 → 0.2.6

package/dist/node_modules/next/dist/server/mcp/get-or-create-mcp-server.js

@@ -15,6 +15,9 @@ const _getpagemetadata = require("./tools/get-page-metadata");
 const _getlogs = require("./tools/get-logs");
 const _getserveractionbyid = require("./tools/get-server-action-by-id");
 const _getroutes = require("./tools/get-routes");
+const _getcompilationissues = require("./tools/get-compilation-issues");
+const _compileroute = require("./tools/compile-route");
+const _getrequestinsights = require("./tools/get-request-insights");
 let mcpServer;
 const getOrCreateMcpServer = (options)=>{
     if (mcpServer) {
@@ -35,6 +38,13 @@ const getOrCreateMcpServer = (options)=>{
         pagesDir: options.pagesDir,
         appDir: options.appDir
     });
+    (0, _getrequestinsights.registerGetRequestInsightsTool)(mcpServer);
+    if (options.getTurbopackProject) {
+        (0, _getcompilationissues.registerGetCompilationIssuesTool)(mcpServer, options.getTurbopackProject);
+    }
+    if (options.compileRoute) {
+        (0, _compileroute.registerCompileRouteTool)(mcpServer, options.compileRoute);
+    }
     return mcpServer;
 };
 

package/dist/node_modules/next/dist/server/mcp/tools/compile-route.js

@@ -0,0 +1,86 @@
+/**
+ * MCP tool for compiling a specific route via the on-demand entry handler.
+ *
+ * Triggers on-demand compilation so the route's assets are built without making an
+ * HTTP request to the route. This is the same call path the dev server uses
+ * when a route is first navigated to, making it useful for warming the module
+ * graph, measuring compile time, or pre-compiling routes for memory
+ * benchmarking without requiring live backends.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerCompileRouteTool", {
+    enumerable: true,
+    get: function() {
+        return registerCompileRouteTool;
+    }
+});
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+const _zod = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/zod"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function registerCompileRouteTool(server, compileRoute) {
+    server.registerTool('compile_route', {
+        description: 'Compile a specific route (page or API route) without making an HTTP request. ' + 'Triggers the same on-demand compilation the dev server uses when a route is first visited. ' + 'Useful for warming up the module graph, measuring compile time, or pre-compiling routes for memory benchmarking. ' + 'Returns { routeSpecifier, issues } on success where routeSpecifier is the resolved route and issues contains any compilation warnings or errors. ' + 'Returns an error if no matching route exists.',
+        inputSchema: {
+            routeSpecifier: _zod.default.string().describe('A route specifier as returned by the get_routes tool (e.g. "/", "/blog/[slug]", "/api/users/[id]"). ' + 'Mutually exclusive with `path`; provide exactly one.').optional(),
+            path: _zod.default.string().describe('A URL path on this site (e.g. "/blog/hello-world", "/docs/a/b/c"). ' + 'Query strings are allowed and ignored. Do not include scheme/host/port. ' + "The path is resolved to its matching route specifier using the dev router's live route table. " + 'Mutually exclusive with `routeSpecifier`; provide exactly one.').optional()
+        }
+    }, async ({ routeSpecifier, path })=>{
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/compile_route');
+        if (routeSpecifier == null === (path == null)) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: 'Provide exactly one of `routeSpecifier` or `path`.'
+                        })
+                    }
+                ]
+            };
+        }
+        try {
+            const { routeSpecifier: resolvedRouteSpecifier, issues } = await compileRoute({
+                routeSpecifier,
+                path
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            routeSpecifier: resolvedRouteSpecifier,
+                            issues
+                        })
+                    }
+                ]
+            };
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const notFound = error instanceof Error && error.code === 'ENOENT';
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(notFound ? {
+                            notFound: true,
+                            input: path ?? routeSpecifier
+                        } : {
+                            input: path ?? routeSpecifier,
+                            error: message
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=compile-route.js.map

package/dist/node_modules/next/dist/server/mcp/tools/get-compilation-issues.js

@@ -0,0 +1,68 @@
+/**
+ * MCP tool for getting compilation issues from all routes via Turbopack.
+ *
+ * Unlike get_errors (which requires a browser session and reflects the runtime
+ * error overlay), this tool builds the module graph for every endpoint and
+ * collects Turbopack issues directly — no browser needed. Covers
+ * module-not-found, syntax errors, and other transform failures across all
+ * routes.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetCompilationIssuesTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetCompilationIssuesTool;
+    }
+});
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+const _formatcompilationissues = require("./utils/format-compilation-issues");
+function registerGetCompilationIssuesTool(server, getProject) {
+    server.registerTool('get_compilation_issues', {
+        description: 'Build the module graph for all routes and return all compilation issues (resolve errors, missing modules, transform errors, etc.). Does not require a browser session. Covers all routes proactively.',
+        inputSchema: {}
+    }, async ()=>{
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_compilation_issues');
+        try {
+            const project = getProject();
+            if (!project) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'Turbopack project is not available. This tool requires the Turbopack bundler.'
+                            })
+                        }
+                    ]
+                };
+            }
+            const { issues } = await project.getAllCompilationIssues();
+            const formattedIssues = (0, _formatcompilationissues.formatCompilationIssues)(issues);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            issues: formattedIssues
+                        })
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error)
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=get-compilation-issues.js.map

package/dist/node_modules/next/dist/server/mcp/tools/get-request-insights.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetRequestInsightsTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetRequestInsightsTool;
+    }
+});
+const _zod = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/zod"));
+const _requestinsights = require("../../lib/trace/request-insights");
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function registerGetRequestInsightsTool(server) {
+    server.registerTool('get_request_insights', {
+        description: 'Get recent App Router request insights captured by the local Next.js span recorder. Useful for debugging slow renders, server fetches, cache behavior, and request timelines without an external OTEL collector. Requires experimental.requestInsights.',
+        inputSchema: {
+            requestId: _zod.default.string().optional(),
+            htmlRequestId: _zod.default.string().optional()
+        }
+    }, async (request)=>{
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_request_insights');
+        if (!(0, _requestinsights.isRequestInsightsEnabled)()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: 'Request Insights is not enabled. Set experimental.requestInsights = true in next.config.js and restart next dev.'
+                        })
+                    }
+                ]
+            };
+        }
+        const snapshot = (0, _requestinsights.getRequestInsightsSnapshot)();
+        const requests = snapshot.requests.filter((insight)=>{
+            return (request.requestId === undefined || insight.requestId === request.requestId) && (request.htmlRequestId === undefined || insight.htmlRequestId === request.htmlRequestId);
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        requests
+                    }, null, 2)
+                }
+            ]
+        };
+    });
+}
+
+//# sourceMappingURL=get-request-insights.js.map

package/dist/node_modules/next/dist/server/mcp/tools/utils/format-compilation-issues.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatCompilationIssues", {
+    enumerable: true,
+    get: function() {
+        return formatCompilationIssues;
+    }
+});
+const _stripansi = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/strip-ansi"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/** Convert a StyledString tree to Markdown. */ function styledStringToMarkdown(s) {
+    switch(s.type){
+        case 'text':
+            return s.value;
+        case 'code':
+            return `\`${s.value}\``;
+        case 'strong':
+            return `**${s.value}**`;
+        case 'line':
+            return s.value.map(styledStringToMarkdown).join('');
+        case 'stack':
+            return s.value.map(styledStringToMarkdown).join('\n');
+        default:
+            return '';
+    }
+}
+function formatCompilationIssues(issues) {
+    const seen = new Set();
+    const formattedIssues = [];
+    for (const issue of issues){
+        var _issue_source_range, _issue_source, _issue_source_range1, _issue_source1;
+        const title = styledStringToMarkdown(issue.title);
+        // Include source position in the key so two distinct errors in the same
+        // file with the same message are not collapsed into one.
+        const startLine = ((_issue_source = issue.source) == null ? void 0 : (_issue_source_range = _issue_source.range) == null ? void 0 : _issue_source_range.start.line) ?? '';
+        const startCol = ((_issue_source1 = issue.source) == null ? void 0 : (_issue_source_range1 = _issue_source1.range) == null ? void 0 : _issue_source_range1.start.column) ?? '';
+        const key = `${issue.severity}|${issue.filePath}|${title}|${startLine}:${startCol}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const { range } = issue.source ?? {};
+        formattedIssues.push({
+            severity: issue.severity,
+            filePath: issue.filePath,
+            title,
+            description: issue.description ? styledStringToMarkdown(issue.description) : undefined,
+            detail: issue.detail ? styledStringToMarkdown(issue.detail) : undefined,
+            source: issue.source ? {
+                filePath: issue.source.source.filePath,
+                range: range ? {
+                    start: {
+                        line: range.start.line + 1,
+                        column: range.start.column + 1
+                    },
+                    end: {
+                        line: range.end.line + 1,
+                        column: range.end.column + 1
+                    }
+                } : undefined
+            } : undefined,
+            codeFrame: issue.codeFrame ? (0, _stripansi.default)(issue.codeFrame) : undefined
+        });
+    }
+    return formattedIssues;
+}
+
+//# sourceMappingURL=format-compilation-issues.js.map

package/dist/node_modules/next/dist/server/mcp/tools/utils/resolve-path-to-route.js

@@ -0,0 +1,49 @@
+/**
+ * Resolves a URL path (e.g. "/blog/hello-world") to its matching Next.js route
+ * specifier (e.g. "/blog/[slug]") using the dev router's own live route table.
+ *
+ * The `matchers` argument is a thin view of `fsChecker` from the router-server
+ * process — the same data structure `resolve-routes.ts` iterates on every
+ * incoming HTTP request — so first-match ordering and live route updates are
+ * inherited for free.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolvePathToRoute", {
+    enumerable: true,
+    get: function() {
+        return resolvePathToRoute;
+    }
+});
+function resolvePathToRoute(path, matchers) {
+    let pathname = path;
+    const q = pathname.indexOf('?');
+    if (q >= 0) pathname = pathname.slice(0, q);
+    const h = pathname.indexOf('#');
+    if (h >= 0) pathname = pathname.slice(0, h);
+    if (!pathname.startsWith('/')) pathname = '/' + pathname;
+    if (pathname !== '/' && pathname.endsWith('/')) {
+        pathname = pathname.slice(0, -1);
+    }
+    if (matchers.appFiles.has(pathname) || matchers.pageFiles.has(pathname)) {
+        return {
+            routeSpecifier: pathname
+        };
+    }
+    for (const route of matchers.dynamicRoutes){
+        // Skip SSG/SSP data-route variants prepended by setup-dev-bundler.
+        if (route.page.startsWith('/_next/data/')) continue;
+        if (route.match(pathname)) {
+            return {
+                routeSpecifier: route.page
+            };
+        }
+    }
+    return {
+        notFound: true,
+        pathname
+    };
+}
+
+//# sourceMappingURL=resolve-path-to-route.js.map

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

@@ -456,6 +456,11 @@ class NextNodeServer extends _baseserver.default {
         if (this.renderOpts.nextScriptWorkers) {
             process.env.__NEXT_SCRIPT_WORKERS = JSON.stringify(true);
         }
+        if ((isDev || process.env.__NEXT_DEV_SERVER) && this.nextConfig.experimental.requestInsights) {
+            process.env.__NEXT_REQUEST_INSIGHTS = 'true';
+        } else {
+            delete process.env.__NEXT_REQUEST_INSIGHTS;
+        }
         if (!this.minimalMode) {
             this.imageResponseCache = new _responsecache.default(this.minimalMode);
         }
@@ -497,8 +502,8 @@ 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) {
-            // immutableAssetToken only works with Turbopack, and `isExperimentalCompile` isn't supported
-            // with that anyway, so we can assign immutableAssetToken to deploymentId here
+            // supportsImmutableAssets only works with Turbopack, and `isExperimentalCompile` isn't supported
+            // with that anyway, so we can assign just use 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);
@@ -693,7 +698,12 @@ class NextNodeServer extends _baseserver.default {
         (0, _requestmeta.addRequestMeta)(req.originalRequest, 'relativeProjectDir', (0, _path.relative)(process.cwd(), this.dir));
         (0, _requestmeta.addRequestMeta)(req.originalRequest, 'distDir', this.distDir);
         await module.handler(req.originalRequest, res.originalResponse, {
-            waitUntil: this.getWaitUntil()
+            waitUntil: this.getWaitUntil(),
+            requestMeta: {
+                ...(0, _requestmeta.getRequestMeta)(req.originalRequest),
+                query,
+                params: match.params
+            }
         });
         return true;
     }
@@ -719,7 +729,7 @@ class NextNodeServer extends _baseserver.default {
                 null, renderOpts, this.getServerComponentsHmrCache(), {
                     buildId: this.buildId,
                     deploymentId: this.deploymentId,
-                    clientAssetToken: this.nextConfig.experimental.immutableAssetToken ?? this.deploymentId
+                    clientAssetToken: this.nextConfig.supportsImmutableAssets ? '' : this.deploymentId
                 });
             } else {
                 // TODO: re-enable this once we've refactored to use implicit matches
@@ -727,7 +737,7 @@ class NextNodeServer extends _baseserver.default {
                 return (0, _modulerender1.lazyRenderPagesPage)(req.originalRequest, res.originalResponse, pathname, query, renderOpts, {
                     buildId: this.buildId,
                     deploymentId: this.deploymentId,
-                    clientAssetToken: this.nextConfig.experimental.immutableAssetToken ?? this.deploymentId,
+                    clientAssetToken: this.nextConfig.supportsImmutableAssets ? undefined : this.deploymentId,
                     customServer: this.serverOptions.customServer || undefined
                 }, {
                     isFallback: false,
@@ -1113,7 +1123,7 @@ class NextNodeServer extends _baseserver.default {
             });
         }
         // Middleware is skipped for on-demand revalidate requests
-        if ((0, _apiutils.checkIsOnDemandRevalidate)(params.request, this.renderOpts.previewProps).isOnDemandRevalidate) {
+        if ((0, _apiutils.checkIsOnDemandRevalidate)(params.request.headers, this.renderOpts.previewProps).isOnDemandRevalidate) {
             return {
                 response: new Response(null, {
                     headers: {
@@ -1189,14 +1199,18 @@ class NextNodeServer extends _baseserver.default {
                 'GET'
             ].includes(params.request.method) && Boolean(requestData.body);
             try {
-                result = await adapterFn({
-                    handler: middlewareModule.proxy || middlewareModule.middleware || middlewareModule,
-                    request: {
-                        ...requestData,
-                        body: hasRequestBody ? requestData.body.cloneBodyStream() : undefined
-                    },
-                    page: 'middleware'
-                });
+                // Node.js middleware runs in-process, inside the active
+                // `handleRequest` span. Detach that span so the middleware span
+                // becomes a sibling root (or parents to an incoming traceparent),
+                // matching edge middleware which runs in a detached sandbox.
+                result = await (0, _tracer.getTracer)().runWithDetachedContext(()=>adapterFn({
+                        handler: middlewareModule.proxy || middlewareModule.middleware || middlewareModule,
+                        request: {
+                            ...requestData,
+                            body: hasRequestBody ? requestData.body.cloneBodyStream() : undefined
+                        },
+                        page: 'middleware'
+                    }));
             } finally{
                 if (hasRequestBody) {
                     await requestData.body.finalize();
@@ -1212,7 +1226,7 @@ class NextNodeServer extends _baseserver.default {
                 request: requestData,
                 useCache: true,
                 onWarning: params.onWarning,
-                clientAssetToken: this.nextConfig.experimental.immutableAssetToken || this.deploymentId
+                clientAssetToken: this.nextConfig.supportsImmutableAssets ? '' : this.deploymentId
             });
         }
         if (!this.dev) {
@@ -1347,7 +1361,7 @@ class NextNodeServer extends _baseserver.default {
             onWarning: params.onWarning,
             incrementalCache: globalThis.__incrementalCache || (0, _requestmeta.getRequestMeta)(params.req, 'incrementalCache'),
             serverComponentsHmrCache: (0, _requestmeta.getRequestMeta)(params.req, 'serverComponentsHmrCache'),
-            clientAssetToken: this.nextConfig.experimental.immutableAssetToken || this.deploymentId
+            clientAssetToken: this.nextConfig.supportsImmutableAssets ? '' : this.deploymentId
         });
         if (result.fetchMetrics) {
             params.req.fetchMetrics = result.fetchMetrics;

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

@@ -88,6 +88,20 @@ const getServerImpl = async ()=>{
     return ServerImpl;
 };
 const SYMBOL_LOAD_CONFIG = Symbol('next.load_config');
+const DEPRECATED_CUSTOM_SERVER_METHOD_GUIDANCE = {
+    setAssetPrefix: 'Please configure `assetPrefix` in `next.config.js` instead.',
+    logError: 'Please use application logging instead.',
+    logErrorWithOriginalStack: 'Please use application logging instead.',
+    revalidate: 'Please use documented application revalidation APIs instead.',
+    render: 'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
+    renderToHTML: 'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
+    renderError: 'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
+    renderErrorToHTML: 'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
+    render404: 'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.'
+};
+function warnDeprecatedCustomServerMethod(method) {
+    _log.warnOnce(`The \`app.${method}()\` method is deprecated in custom servers. ${DEPRECATED_CUSTOM_SERVER_METHOD_GUIDANCE[method]}`);
+}
 class NextServer {
     constructor(options){
         this.options = options;
@@ -100,10 +114,11 @@ class NextServer {
     }
     getRequestHandler() {
         return async (req, res, parsedUrl)=>{
-            return (0, _tracer.getTracer)().trace(_constants2.NextServerSpan.getRequestHandler, async ()=>{
-                const requestHandler = await this.getServerRequestHandler();
-                return requestHandler(req, res, parsedUrl);
-            });
+            const tracer = (0, _tracer.getTracer)();
+            return tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants2.NextServerSpan.getRequestHandler, async ()=>{
+                    const requestHandler = await this.getServerRequestHandler();
+                    return requestHandler(req, res, parsedUrl);
+                }));
         };
     }
     /**
@@ -111,11 +126,12 @@ class NextServer {
    * directly by end-users, only used in testing
    */ getRequestHandlerWithMetadata(meta) {
         return async (req, res, parsedUrl)=>{
-            return (0, _tracer.getTracer)().trace(_constants2.NextServerSpan.getRequestHandlerWithMetadata, async ()=>{
-                const server = await this.getServer();
-                const handler = server.getRequestHandlerWithMetadata(meta);
-                return handler(req, res, parsedUrl);
-            });
+            const tracer = (0, _tracer.getTracer)();
+            return tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants2.NextServerSpan.getRequestHandlerWithMetadata, async ()=>{
+                    const server = await this.getServer();
+                    const handler = server.getRequestHandlerWithMetadata(meta);
+                    return handler(req, res, parsedUrl);
+                }));
         };
     }
     getUpgradeHandler() {
@@ -332,6 +348,7 @@ class NextServer {
         };
     }
     async render(...args) {
+        warnDeprecatedCustomServerMethod('render');
         let [req, res, pathname, query, parsedUrl] = args;
         this.setupWebSocketHandler(this.options.httpServer, req);
         if (!pathname.startsWith('/')) {
@@ -349,6 +366,7 @@ class NextServer {
     }
     setAssetPrefix(assetPrefix) {
         var _routerServerGlobal_RouterServerContextSymbol_relativeProjectDir, _routerServerGlobal_RouterServerContextSymbol;
+        warnDeprecatedCustomServerMethod('setAssetPrefix');
         this.server.setAssetPrefix(assetPrefix);
         // update the router-server nextConfig instance as
         // this is the source of truth for "handler" in serverful
@@ -361,24 +379,31 @@ class NextServer {
         return this.server.getUpgradeHandler();
     }
     logError(...args) {
+        warnDeprecatedCustomServerMethod('logError');
         this.server.logError(...args);
     }
     logErrorWithOriginalStack(err, type) {
+        warnDeprecatedCustomServerMethod('logErrorWithOriginalStack');
         return this.server.logErrorWithOriginalStack(err, type);
     }
     async revalidate(...args) {
+        warnDeprecatedCustomServerMethod('revalidate');
         return this.server.revalidate(...args);
     }
     async renderToHTML(...args) {
+        warnDeprecatedCustomServerMethod('renderToHTML');
         return this.server.renderToHTML(...args);
     }
     async renderError(...args) {
+        warnDeprecatedCustomServerMethod('renderError');
         return this.server.renderError(...args);
     }
     async renderErrorToHTML(...args) {
+        warnDeprecatedCustomServerMethod('renderErrorToHTML');
         return this.server.renderErrorToHTML(...args);
     }
     async render404(...args) {
+        warnDeprecatedCustomServerMethod('render404');
         return this.server.render404(...args);
     }
     async close() {
@@ -396,15 +421,20 @@ function createServer(options) {
     if (isCustomServer) {
         const selectTurbopack = options && (options.turbo || options.turbopack || process.env.IS_TURBOPACK_TEST);
         const selectWebpack = options && (options.webpack || process.env.IS_WEBPACK_TEST);
-        if (selectTurbopack && selectWebpack) {
+        // Rspack is selected through env/config side effects instead of a custom
+        // server option, so don't fall back to the default Turbopack auto mode.
+        const selectRspack = !!process.env.NEXT_RSPACK;
+        if (selectTurbopack && selectWebpack && selectRspack) {
             throw Object.defineProperty(new Error('Pass either `webpack` or `turbopack`, not both.'), "__NEXT_ERROR_CODE", {
                 value: "E851",
                 enumerable: false,
                 configurable: true
             });
         }
-        if (selectTurbopack || !selectWebpack) {
-            process.env.TURBOPACK ??= selectTurbopack ? '1' : 'auto';
+        if (selectTurbopack) {
+            process.env.TURBOPACK ??= '1';
+        } else if (!selectWebpack && !selectRspack) {
+            process.env.TURBOPACK ??= 'auto';
         }
     } else {
         if (options && (options.webpack || options.turbo || options.turbopack)) {