@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/lib/router-utils/proxy-request.js

@@ -21,9 +21,13 @@ async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTime
     const { query } = parsedUrl;
     delete parsedUrl.query;
     parsedUrl.search = (0, _serverrouteutils.stringifyQuery)(req, query);
-    const target = _url.default.format(parsedUrl);
-    const HttpProxy = require('next/dist/compiled/http-proxy');
-    const proxy = new HttpProxy({
+    // Keep in mind that a WHATWG URL's hostname and the parsedUrl's hostname
+    // are not strictly equal due to lowercasing, IDN translation, IPv4 and IPv6 normalization, etc.
+    // We just make sure this is a valid URL since httpxy would only parse it
+    // lazily on the `web()`/`ws()` call.
+    const target = new URL(_url.default.format(parsedUrl));
+    const { ProxyServer } = require('next/dist/compiled/httpxy');
+    const proxy = new ProxyServer({
         target,
         changeOrigin: true,
         ignorePath: true,
@@ -36,7 +40,7 @@ async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTime
         }
     });
     let finished = false;
-    // http-proxy does not properly detect a client disconnect in newer
+    // httpxy does not properly detect a client disconnect in newer
     // versions of Node.js. This is caused because it only listens for the
     // `aborted` event on the our request object, but it also fully reads
     // and closes the request object. Node **will not** fire `aborted` when
@@ -70,10 +74,10 @@ async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTime
         innerRes.once('close', cleanup);
     });
     const detached = new _detachedpromise.DetachedPromise();
-    proxy.on('error', (err)=>{
-        console.error(`Failed to proxy ${target}`, err);
+    const onProxyError = (err)=>{
         if (!finished) {
             finished = true;
+            console.error(`Failed to proxy ${target}`, err);
             detached.reject(err);
             if (!res.destroyed) {
                 if (!(res instanceof _stream.Duplex)) {
@@ -82,7 +86,8 @@ async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTime
                 res.end('Internal Server Error');
             }
         }
-    });
+    };
+    proxy.on('error', onProxyError);
     // If upgrade head is present or the response is a Duplex stream, treat as
     // WebSocket request.
     if (upgradeHead || res instanceof _stream.Duplex) {
@@ -94,7 +99,9 @@ async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTime
                 }
             });
         });
-        proxy.ws(req, res, upgradeHead);
+        // The returned promise rejects on errors of the client socket (e.g. an
+        // abrupt client disconnect) even when an `error` listener is registered.
+        proxy.ws(req, res, {}, upgradeHead).catch(onProxyError);
         detached.resolve(true);
     } else {
         proxy.on('proxyReq', (proxyReq)=>{
@@ -105,9 +112,12 @@ async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTime
                 }
             });
         });
+        // The returned promise rejects on errors of the client response stream
+        // (e.g. an abrupt client disconnect) even when an `error` listener is
+        // registered.
         proxy.web(req, res, {
             buffer: reqBody
-        });
+        }).catch(onProxyError);
     }
     // When the proxy finishes proxying the request, shut down the proxy.
     return detached.promise.finally(()=>{

package/dist/node_modules/next/dist/server/lib/router-utils/resolve-routes.js

@@ -309,8 +309,11 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                                 (0, _requestmeta.addRequestMeta)(req, 'locale', output.locale);
                             }
                             if (process.env.__NEXT_TEST_MODE && process.env.IS_TURBOPACK_TEST && output.type === 'nextStaticFolder' && config.deploymentId) {
-                                let useImmutableToken = config.experimental.immutableAssetToken && clientHashes[`static${decodeURI(output.itemPath)}`];
-                                const expectedToken = useImmutableToken ? config.experimental.immutableAssetToken : config.deploymentId;
+                                let isImmutableFile = config.supportsImmutableAssets && clientHashes[`static${decodeURI(output.itemPath)}`];
+                                // Service workers are served at a fixed, stable URL (so the browser can keep the
+                                // same registration across builds), so they don't carry a `?dpl` token.
+                                const isServiceWorker = output.itemPath.startsWith('/service-worker/');
+                                const expectedToken = isImmutableFile || isServiceWorker ? undefined : config.deploymentId;
                                 if (parsedUrl.query.dpl !== expectedToken) {
                                     console.error(`Invalid dpl query param: ${req.url}, expected: ${expectedToken}`);
                                     return {

package/dist/node_modules/next/dist/server/lib/router-utils/root-params-type-utils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    generateRootParamsTypes: null,
+    writeRootParamsTypes: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    generateRootParamsTypes: function() {
+        return generateRootParamsTypes;
+    },
+    writeRootParamsTypes: function() {
+        return writeRootParamsTypes;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const ROOT_PARAM_VALUE_TYPES = [
+    'string',
+    'string[]',
+    'undefined'
+];
+function generateRootParamsTypes(rootParams) {
+    const exports1 = Array.from(rootParams.entries()).sort(([a], [b])=>a.localeCompare(b)).map(([paramName, info])=>`  export function ${paramName}(): ${getRootParamReturnType(info)}`);
+    return `// Type definitions for Next.js root params (next/root-params)
+
+declare module 'next/root-params' {
+${exports1.join('\n')}
+}
+`;
+}
+function getRootParamReturnType(valueTypes) {
+    const orderedValueTypes = ROOT_PARAM_VALUE_TYPES.filter((valueType)=>valueTypes.has(valueType));
+    return `Promise<${orderedValueTypes.join(' | ')}>`;
+}
+async function writeRootParamsTypes(manifest, filePath) {
+    const rootParams = manifest.rootParams;
+    await _fs.default.promises.mkdir(_path.default.dirname(filePath), {
+        recursive: true
+    });
+    if (!rootParams.size) {
+        // Write an empty declaration so the import in next-env.d.ts resolves.
+        await _fs.default.promises.writeFile(filePath, `// Type definitions for Next.js root params (next/root-params)\n// No root params detected.\nexport {}\n`);
+        return;
+    }
+    await _fs.default.promises.writeFile(filePath, generateRootParamsTypes(rootParams));
+}
+
+//# sourceMappingURL=root-params-type-utils.js.map

package/dist/node_modules/next/dist/server/lib/router-utils/route-types-utils.js

@@ -127,6 +127,43 @@ function extractRouteParams(route) {
         return route;
     }
 }
+/**
+ * Collects root params from the manifest's layout routes with universality tracking.
+ * A root layout is the shallowest layout in each branch — no ancestor layout above it.
+ * A param is "universal" if it appears in ALL root layouts.
+ *
+ * Uses the already-extracted `groups` from `manifest.layoutRoutes` (via `getRouteRegex`)
+ * rather than re-parsing segments.
+ */ function collectRootParamsFromLayouts(layoutRoutes) {
+    const routes = Object.keys(layoutRoutes);
+    // Find root layouts: layouts with no ancestor layout above them.
+    const rootLayoutRoutes = routes.filter(// If there are no other layouts whose paths are prefixes of this layout,
+    // then it's a root layout.
+    (route)=>!routes.some((other)=>other !== route && (other === '/' || route.startsWith(other + '/'))));
+    if (rootLayoutRoutes.length === 0) {
+        return new Map();
+    }
+    // The same param name can have different runtime shapes
+    // across roots, so track both param names and shapes.
+    const rootParams = new Map();
+    for (const route of rootLayoutRoutes){
+        for (const [name, group] of Object.entries(layoutRoutes[route].groups)){
+            const info = rootParams.get(name) ?? new Set();
+            info.add(group.repeat ? 'string[]' : 'string');
+            if (group.optional) {
+                info.add('undefined');
+            }
+            rootParams.set(name, info);
+        }
+    }
+    // Any param missing from a root layout can be undefined.
+    for (const [name, info] of rootParams){
+        if (rootLayoutRoutes.some((route)=>!(name in layoutRoutes[route].groups))) {
+            info.add('undefined');
+        }
+    }
+    return rootParams;
+}
 async function createRouteTypesManifest({ dir, pageRoutes, appRoutes, appRouteHandlers, pageApiRoutes, layoutRoutes, slots, redirects, rewrites, validatorFilePath }) {
     // Helper function to calculate the correct relative path
     const getRelativePath = (filePath)=>{
@@ -144,6 +181,7 @@ async function createRouteTypesManifest({ dir, pageRoutes, appRoutes, appRouteHa
         appRouteHandlerRoutes: {},
         redirectRoutes: {},
         rewriteRoutes: {},
+        rootParams: new Map(),
         appRouteHandlers: new Set(appRouteHandlers.map(({ filePath })=>getRelativePath(filePath))),
         pageApiRoutes: new Set(pageApiRoutes.map(({ filePath })=>getRelativePath(filePath))),
         appPagePaths: new Set(appRoutes.map(({ filePath })=>getRelativePath(filePath))),
@@ -256,6 +294,8 @@ async function createRouteTypesManifest({ dir, pageRoutes, appRoutes, appRouteHa
             }
         }
     }
+    // Collect root params from layout routes
+    manifest.rootParams = collectRootParamsFromLayouts(manifest.layoutRoutes);
     return manifest;
 }
 async function writeRouteTypesManifest(manifest, filePath, config) {

package/dist/node_modules/next/dist/server/lib/router-utils/typegen.js

@@ -179,33 +179,65 @@ function formatRouteToRouteType(route) {
     };
 }
 // Helper function to serialize route types (matches the plugin logic exactly)
+// Each entry is a [routeType, source] tuple.
 function serializeRouteTypes(routeTypes) {
     // route collection is not deterministic, this makes the output of the file deterministic
-    return routeTypes.sort().map((route)=>`\n    | \`${route}\``).join('');
+    routeTypes.sort(([a], [b])=>a.localeCompare(b));
+    let union = '';
+    for(let i = 0; i < routeTypes.length; i++){
+        const [route, cause] = routeTypes[i];
+        union += `\n    | \`${route}\` // ${cause}`;
+    }
+    return union;
 }
 function generateLinkTypesFile(routesManifest) {
-    // Generate serialized static and dynamic routes for the internal namespace
-    // Build a unified set of routes across app/pages/redirect/rewrite as well as
-    // app route handlers and Pages Router API routes.
-    const allRoutesSet = new Set([
-        ...Object.keys(routesManifest.appRoutes),
-        ...Object.keys(routesManifest.pageRoutes),
-        ...Object.keys(routesManifest.redirectRoutes),
-        ...Object.keys(routesManifest.rewriteRoutes),
-        // Allow linking to App Route Handlers (e.g. `/logout/route.ts`)
-        ...Object.keys(routesManifest.appRouteHandlerRoutes),
-        // Allow linking to Pages Router API routes (e.g. `/api/*`)
-        ...Array.from(routesManifest.pageApiRoutes)
-    ]);
+    const visited = new Set();
     const staticRouteTypes = [];
     const dynamicRouteTypes = [];
-    // Process each route using the same logic as the plugin
-    for (const route of allRoutesSet){
-        const { isDynamic, routeType } = formatRouteToRouteType(route);
+    for (const routeMap of [
+        routesManifest.appRoutes,
+        routesManifest.pageRoutes,
+        routesManifest.redirectRoutes,
+        routesManifest.rewriteRoutes,
+        routesManifest.appRouteHandlerRoutes
+    ]){
+        for(const route in routeMap){
+            if (visited.has(route)) {
+                continue;
+            }
+            visited.add(route);
+            const { isDynamic, routeType } = formatRouteToRouteType(route);
+            const cause = routeMap[route].path;
+            if (isDynamic) {
+                dynamicRouteTypes.push([
+                    routeType,
+                    cause
+                ]);
+            } else {
+                staticRouteTypes.push([
+                    routeType,
+                    cause
+                ]);
+            }
+        }
+    }
+    // Pages Router API routes are stored as file paths
+    for (const filePath of routesManifest.pageApiRoutes){
+        if (visited.has(filePath)) {
+            continue;
+        }
+        visited.add(filePath);
+        const { isDynamic, routeType } = formatRouteToRouteType(filePath);
         if (isDynamic) {
-            dynamicRouteTypes.push(routeType);
+            dynamicRouteTypes.push([
+                routeType,
+                filePath
+            ]);
         } else {
-            staticRouteTypes.push(routeType);
+            staticRouteTypes.push([
+                routeType,
+                filePath
+            ]);
         }
     }
     const serializedStaticRouteTypes = serializeRouteTypes(staticRouteTypes);
@@ -328,7 +360,8 @@ declare module 'next/navigation' {
    * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
    *
    * - In a Server Component, this will insert a meta tag to redirect the user to the target page.
-   * - In a Route Handler or Server Action, it will serve a 307/303 to the caller.
+   * - In a Route Handler, it will serve a 307 to the caller.
+   * - In a Server Action, it will perform a client-side navigation when JavaScript is available or serve a 303 for a progressive enhancement form submission.
    * - In a Server Action, type defaults to 'push' and 'replace' elsewhere.
    *
    * Read more: [Next.js Docs: redirect](https://nextjs.org/docs/app/api-reference/functions/redirect)
@@ -346,7 +379,8 @@ declare module 'next/navigation' {
    * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
    *
    * - In a Server Component, this will insert a meta tag to redirect the user to the target page.
-   * - In a Route Handler or Server Action, it will serve a 308/303 to the caller.
+   * - In a Route Handler, it will serve a 308 to the caller.
+   * - In a Server Action, it will perform a client-side navigation when JavaScript is available or serve a 303 for a progressive enhancement form submission.
    *
    * Read more: [Next.js Docs: redirect](https://nextjs.org/docs/app/api-reference/functions/redirect)
    */

package/dist/node_modules/next/dist/server/lib/source-maps.js

@@ -6,8 +6,10 @@ Object.defineProperty(exports, "__esModule", {
     devirtualizeReactServerURL: null,
     filterStackFrameDEV: null,
     findApplicableSourceMapPayload: null,
+    findSourceMapPayload: null,
     findSourceMapURLDEV: null,
     ignoreListAnonymousStackFramesIfSandwiched: null,
+    setBundlerFindSourceMapURLImplementation: null,
     sourceMapIgnoreListsEverything: null
 });
 function _export(target, all) {
@@ -26,12 +28,18 @@ _export(exports, {
     findApplicableSourceMapPayload: function() {
         return findApplicableSourceMapPayload;
     },
+    findSourceMapPayload: function() {
+        return findSourceMapPayload;
+    },
     findSourceMapURLDEV: function() {
         return findSourceMapURLDEV;
     },
     ignoreListAnonymousStackFramesIfSandwiched: function() {
         return ignoreListAnonymousStackFramesIfSandwiched;
     },
+    setBundlerFindSourceMapURLImplementation: function() {
+        return setBundlerFindSourceMapURLImplementation;
+    },
     sourceMapIgnoreListsEverything: function() {
         return sourceMapIgnoreListsEverything;
     }
@@ -42,6 +50,22 @@ function noSourceMap() {
 }
 // Edge runtime does not implement `module`
 const findSourceMap = process.env.NEXT_RUNTIME === 'edge' ? noSourceMap : require('module').findSourceMap;
+// `SourceMap#payload` deep-clones the payload on every access — expensive
+// for large chunk maps — so the clone is shared per `SourceMap` instance,
+// which Node.js memoizes per script.
+const sourceMapPayloads = new WeakMap();
+function findSourceMapPayload(sourceURL) {
+    const sourceMap = findSourceMap(sourceURL);
+    if (sourceMap === undefined) {
+        return undefined;
+    }
+    let payload = sourceMapPayloads.get(sourceMap);
+    if (payload === undefined) {
+        payload = sourceMap.payload;
+        sourceMapPayloads.set(sourceMap, payload);
+    }
+    return payload;
+}
 function sourceMapIgnoreListsEverything(sourceMap) {
     return sourceMap.ignoreList !== undefined && sourceMap.sources.length === sourceMap.ignoreList.length;
 }
@@ -90,13 +114,12 @@ function filterStackFrameDEV(sourceURL, functionName, line1, column1) {
         // Node.js loads source maps eagerly so this call is cheap.
         // TODO: ESM sourcemaps are O(1) but CommonJS sourcemaps are O(Number of CJS modules).
         // Make sure this doesn't adversely affect performance when CJS is used by Next.js.
-        const sourceMap = findSourceMap(sourceURL);
-        if (sourceMap === undefined) {
-            // No source map assoicated.
-            // TODO: Node.js types should reflect that `findSourceMap` can return `undefined`.
+        const payload = findSourceMapPayload(sourceURL);
+        if (payload === undefined) {
+            // No source map associated.
             return true;
         }
-        const sourceMapPayload = findApplicableSourceMapPayload(line1 - 1, column1 - 1, sourceMap.payload);
+        const sourceMapPayload = findApplicableSourceMapPayload(line1 - 1, column1 - 1, payload);
         if (sourceMapPayload === undefined) {
             // No source map section applicable to the frame.
             return true;
@@ -115,16 +138,38 @@ function filterStackFrameDEV(sourceURL, functionName, line1, column1) {
         return true;
     }
 }
+// Find the URL of a source map using the bundler's API.
+// Shared via `globalThis` because this module is compiled both into the server
+// runtime bundles (which call `findSourceMapURLDEV`) and into `next/dist/server`
+// (where the dev server registers the implementation), and each copy has its own
+// module state.
+const bundlerFindSourceMapURLSymbol = Symbol.for('next.server.bundlerFindSourceMapURL');
+function setBundlerFindSourceMapURLImplementation(findSourceMapURLImplementation) {
+    ;
+    globalThis[bundlerFindSourceMapURLSymbol] = findSourceMapURLImplementation;
+}
+function bundlerFindSourceMapURL(scriptNameOrSourceURL) {
+    const implementation = globalThis[bundlerFindSourceMapURLSymbol];
+    return implementation === undefined ? null : implementation(scriptNameOrSourceURL);
+}
 const invalidSourceMap = Symbol('invalid-source-map');
-const sourceMapURLs = new _lrucache.LRUCache(512 * 1024 * 1024, (url)=>url === invalidSourceMap ? // so that we don't create a huge cache with empty source maps.
-    8 * 1024 : url.length);
+const sourceMapURLs = new _lrucache.LRUCache(512 * 1024 * 1024, (url, sourceURL)=>sourceURL.length + (url === invalidSourceMap ? 8 * 1024 : url.length));
 function findSourceMapURLDEV(scriptNameOrSourceURL) {
+    try {
+        const bundlerSourceMapURL = bundlerFindSourceMapURL(scriptNameOrSourceURL);
+        if (bundlerSourceMapURL !== null) {
+            return bundlerSourceMapURL;
+        }
+    } catch (cause) {
+        console.error(`${scriptNameOrSourceURL}: Failed to find the source map URL. Cause: ${cause}`);
+    }
+    // No bundler implementation (e.g. Webpack): inline the source map Node.js
+    // knows as a `data:` URL.
     let sourceMapURL = sourceMapURLs.get(scriptNameOrSourceURL);
     if (sourceMapURL === undefined) {
         let sourceMapPayload;
         try {
-            var _findSourceMap;
-            sourceMapPayload = (_findSourceMap = findSourceMap(scriptNameOrSourceURL)) == null ? void 0 : _findSourceMap.payload;
+            sourceMapPayload = findSourceMapPayload(scriptNameOrSourceURL);
         } catch (cause) {
             console.error(`${scriptNameOrSourceURL}: Invalid source map. Only conformant source maps can be used to find the original code. Cause: ${cause}`);
         }

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

@@ -32,7 +32,6 @@ const _http = /*#__PURE__*/ _interop_require_default(require("http"));
 const _https = /*#__PURE__*/ _interop_require_default(require("https"));
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
 const _child_process = require("child_process");
-const _watchpack = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/watchpack"));
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
 const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
 const _utils = require("./utils");
@@ -178,7 +177,7 @@ async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server
 async function startServer(serverOptions) {
     const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate, serverFastRefresh } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"16.2.6"})`;
+    process.title = `next-server (v${"16.3.3"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{
@@ -208,6 +207,7 @@ async function startServer(serverOptions) {
         });
     };
     let nextServer;
+    let devMemoryThresholdRestart = true;
     // setup server listener as fast as possible
     if (selfSignedCertificate && !isDev) {
         throw Object.defineProperty(new Error('Using a self signed certificate is only supported with `next dev`.'), "__NEXT_ERROR_CODE", {
@@ -229,16 +229,15 @@ async function startServer(serverOptions) {
             _log.error(`Failed to handle request for ${req.url}`);
             console.error(err);
         } finally{
-            if (isDev) {
-                if (_v8.default.getHeapStatistics().used_heap_size > 0.8 * _v8.default.getHeapStatistics().heap_size_limit) {
-                    _log.warn(`Server is approaching the used memory threshold, restarting...`);
-                    (0, _trace.trace)('server-restart-close-to-memory-threshold', undefined, {
-                        'memory.heapSizeLimit': String(_v8.default.getHeapStatistics().heap_size_limit),
-                        'memory.heapUsed': String(_v8.default.getHeapStatistics().used_heap_size)
-                    }).stop();
-                    await (0, _trace.flushAllTraces)();
-                    process.exit(_utils.RESTART_EXIT_CODE);
-                }
+            const memoryRestartStats = (0, _utils.getMemoryRestartStats)(isDev, devMemoryThresholdRestart, _v8.default.getHeapStatistics);
+            if (memoryRestartStats) {
+                _log.warn(`Server is approaching the used memory threshold, restarting...`);
+                (0, _trace.trace)('server-restart-close-to-memory-threshold', undefined, {
+                    'memory.heapSizeLimit': String(memoryRestartStats.heap_size_limit),
+                    'memory.heapUsed': String(memoryRestartStats.used_heap_size)
+                }).stop();
+                await (0, _trace.flushAllTraces)();
+                process.exit(_utils.RESTART_EXIT_CODE);
             }
         }
     }
@@ -402,6 +401,7 @@ async function startServer(serverOptions) {
                     experimentalHttpsServer: !!selfSignedCertificate,
                     serverFastRefresh
                 });
+                devMemoryThresholdRestart = initResult.devMemoryThresholdRestart;
                 requestHandler = initResult.requestHandler;
                 upgradeHandler = initResult.upgradeHandler;
                 nextServer = initResult.server;
@@ -410,8 +410,23 @@ async function startServer(serverOptions) {
                 if (isDev) {
                     (0, _appinfolog.logExperimentalInfo)({
                         experimentalFeatures: initResult.experimentalFeatures,
-                        cacheComponents: initResult.cacheComponents
+                        cacheComponents: initResult.cacheComponents,
+                        partialPrefetching: initResult.partialPrefetching
                     });
+                    // Auto-generate AGENTS.md / CLAUDE.md when an AI coding agent
+                    // is detected but the managed agent-rules block is missing.
+                    // Gated on `agentRules` in next.config (default true).
+                    if (initResult.agentRules !== false) {
+                        const result = await (0, _appinfolog.ensureAgentRulesForDev)(dir);
+                        if (result) {
+                            const generated = [];
+                            if (result.agentsMd === 'created' || result.agentsMd === 'updated') generated.push('AGENTS.md');
+                            if (result.claudeMd === 'created' || result.claudeMd === 'updated') generated.push('CLAUDE.md');
+                            if (generated.length > 0) {
+                                _log.event(`Generated ${generated.join(' and ')} for AI agents. Set \`agentRules: false\` in next.config to disable.`);
+                            }
+                        }
+                    }
                 }
                 handlersReady();
                 if (process.env.TURBOPACK && isDev) {
@@ -430,22 +445,48 @@ async function startServer(serverOptions) {
         });
         server.listen(port, hostname);
     });
+    // Watch config files for changes and distDir ancestors for deletion.
     if (isDev) {
-        function watchConfigFiles(dirToWatch, onChange) {
-            const wp = new _watchpack.default();
-            wp.watch({
-                files: _constants.CONFIG_FILES.map((file)=>_path.default.join(dirToWatch, file))
-            });
-            wp.on('change', onChange);
+        // Note: dir is absolute and normalized (`..` segments removed), `absDistDir`
+        // is also normalized because `path.join()` performs normalization. `distDir`
+        // does not have to be inside of `dir`!
+        const absDistDir = _path.default.join(dir, distDir);
+        // always watch dir and absDistDir
+        const dirWatchPaths = [
+            dir,
+            absDistDir
+        ];
+        // also watch ancestors of absDistDir that are inside of dir.
+        let prevAncestor = absDistDir;
+        while(true){
+            const nextAncestor = _path.default.dirname(prevAncestor);
+            // note: `dirname('/') === '/'` if we happen to reach the FS root
+            if (!nextAncestor.startsWith(dir + _path.default.sep) || nextAncestor === prevAncestor) {
+                break;
+            }
+            dirWatchPaths.push(nextAncestor);
+            prevAncestor = nextAncestor;
         }
-        watchConfigFiles(dir, async (filename)=>{
-            if (process.env.__NEXT_DISABLE_MEMORY_WATCHER) {
-                _log.info(`Detected change, manual restart required due to '__NEXT_DISABLE_MEMORY_WATCHER' usage`);
+        const configFiles = _constants.CONFIG_FILES.map((file)=>_path.default.join(dir, file));
+        const Watchpack = require('next/dist/compiled/watchpack');
+        const wp = new Watchpack();
+        wp.watch({
+            files: configFiles,
+            missing: dirWatchPaths
+        });
+        wp.on('change', async (filename)=>{
+            if (!configFiles.includes(filename)) {
                 return;
             }
             _log.warn(`Found a change in ${_path.default.basename(filename)}. Restarting the server to apply the changes...`);
             process.exit(_utils.RESTART_EXIT_CODE);
         });
+        wp.on('remove', (removedPath)=>{
+            if (dirWatchPaths.includes(removedPath)) {
+                _log.error(`The directory at "${removedPath}" was deleted.\n\n` + 'Deleting this directory while Next.js is running can lead to ' + 'undefined behavior. Restarting the server to recover...');
+                process.exit(_utils.RESTART_EXIT_CODE);
+            }
+        });
     }
     return {
         distDir
@@ -462,13 +503,18 @@ if (process.env.NEXT_PRIVATE_WORKER && process.send) {
                         value
                     ]));
             }
+            let rageRestartAttrsFromParent = {};
+            if (process.env.NEXT_PRIVATE_DEV_SPAN_ATTRS) {
+                rageRestartAttrsFromParent = JSON.parse(process.env.NEXT_PRIVATE_DEV_SPAN_ATTRS);
+            }
             startServerSpan = (0, _trace.trace)('start-dev-server', undefined, {
                 cpus: String(_os.default.cpus().length),
                 platform: _os.default.platform(),
                 'memory.freeMem': String(_os.default.freemem()),
                 'memory.totalMem': String(_os.default.totalmem()),
                 'memory.heapSizeLimit': String(_v8.default.getHeapStatistics().heap_size_limit),
-                ...enabledFeaturesFromParent
+                ...enabledFeaturesFromParent,
+                ...rageRestartAttrsFromParent
             });
             (0, _trace.initializeTraceState)({
                 ...(0, _trace.exportTraceState)(),

package/dist/node_modules/next/dist/server/lib/streaming-metadata.js

@@ -2,37 +2,26 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-0 && (module.exports = {
-    isHtmlBotRequest: null,
-    shouldServeStreamingMetadata: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    isHtmlBotRequest: function() {
-        return isHtmlBotRequest;
-    },
-    shouldServeStreamingMetadata: function() {
+Object.defineProperty(exports, "shouldServeStreamingMetadata", {
+    enumerable: true,
+    get: function() {
         return shouldServeStreamingMetadata;
     }
 });
 const _isbot = require("../../shared/lib/router/utils/is-bot");
+let cachedPattern;
+let cachedRegex;
 function shouldServeStreamingMetadata(userAgent, htmlLimitedBots) {
-    const blockingMetadataUARegex = new RegExp(htmlLimitedBots || _isbot.HTML_LIMITED_BOT_UA_RE_STRING, 'i');
+    const pattern = htmlLimitedBots || _isbot.HTML_LIMITED_BOT_UA_RE_STRING;
+    if (cachedPattern !== pattern) {
+        cachedPattern = pattern;
+        cachedRegex = new RegExp(pattern, 'i');
+    }
     // Only block metadata for HTML-limited bots
-    if (userAgent && blockingMetadataUARegex.test(userAgent)) {
+    if (userAgent && cachedRegex.test(userAgent)) {
         return false;
     }
     return true;
 }
-function isHtmlBotRequest(req) {
-    const ua = req.headers['user-agent'] || '';
-    const botType = (0, _isbot.getBotType)(ua);
-    return botType === 'html';
-}
 
 //# sourceMappingURL=streaming-metadata.js.map

package/dist/node_modules/next/dist/server/lib/trace/constants.js

@@ -153,6 +153,11 @@ var AppRenderSpan = /*#__PURE__*/ function(AppRenderSpan) {
     AppRenderSpan["renderToReadableStream"] = "AppRender.renderToReadableStream";
     AppRenderSpan["getBodyResult"] = "AppRender.getBodyResult";
     AppRenderSpan["fetch"] = "AppRender.fetch";
+    AppRenderSpan["waitShellReady"] = "AppRender.waitShellReady";
+    AppRenderSpan["renderToNodeFizzStream"] = "AppRender.renderToNodeFizzStream";
+    AppRenderSpan["instantInsights"] = "AppRender.instantInsights";
+    AppRenderSpan["instantInsightsPrepareValidation"] = "AppRender.instantInsights.prepareValidation";
+    AppRenderSpan["instantInsightsRunValidation"] = "AppRender.instantInsights.runValidation";
     return AppRenderSpan;
 }(AppRenderSpan || {});
 var RouterSpan = /*#__PURE__*/ function(RouterSpan) {