@claudeye/linux-arm64 1.0.6-beta.1 → 1.0.6-beta.3

package/assets/standalone/node_modules/next/dist/server/lib/router-utils/block-cross-site-dev.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "blockCrossSiteDEV", {
+    enumerable: true,
+    get: function() {
+        return blockCrossSiteDEV;
+    }
+});
+const _url = require("../../../lib/url");
+const _log = require("../../../build/output/log");
+const _csrfprotection = require("../../app-render/csrf-protection");
+const allowedDevOriginsDocs = 'https://nextjs.org/docs/app/api-reference/config/next-config-js/allowedDevOrigins';
+function getBlockedResourcePath(req) {
+    var _parseUrl;
+    return ((_parseUrl = (0, _url.parseUrl)(req.url ?? '')) == null ? void 0 : _parseUrl.pathname) ?? req.url ?? '/_next/*';
+}
+function formatBlockedCrossSiteMessage(source, resourcePath) {
+    const lines = [
+        `Blocked cross-origin request to Next.js dev resource ${resourcePath}${getBlockedSourceDescription(source)}.`,
+        'Cross-origin access to Next.js dev resources is blocked by default for safety.'
+    ];
+    // `source` has 3 meanings here:
+    // - `'null'`: browser explicitly sent `Origin: null` for an opaque/sandboxed origin
+    // - hostname string: we parsed an allowlistable host from Origin/Referer
+    // - `undefined` (and effectively empty string): the request did not include a usable host
+    if (source === 'null') {
+        lines.push('', 'This request came from a privacy-sensitive or opaque origin, so Next.js cannot determine which host to allow.', 'If you need it to succeed, load the dev server from a normal origin and add that host to "allowedDevOrigins".');
+    } else if (source) {
+        lines.push('', 'To allow this host in development, add it to "allowedDevOrigins" in next.config.js and restart the dev server:', '', '// next.config.js', 'module.exports = {', `  allowedDevOrigins: ['${source}'],`, '}');
+    } else {
+        lines.push('', 'This request did not include an allowlistable source host.', 'If you need it to succeed, make sure the browser sends an Origin or Referer from a host listed in "allowedDevOrigins".');
+    }
+    lines.push('', `Read more: ${allowedDevOriginsDocs}`);
+    return lines.join('\n');
+}
+function getBlockedSourceDescription(source) {
+    if (source === 'null') {
+        return ' from a privacy-sensitive or opaque origin';
+    }
+    if (source) {
+        return ` from "${source}"`;
+    }
+    return ' from an unknown source';
+}
+function blockRequest(req, res, source) {
+    (0, _log.warnOnce)(formatBlockedCrossSiteMessage(source, getBlockedResourcePath(req)));
+    if ('statusCode' in res) {
+        res.statusCode = 403;
+    }
+    res.end('Unauthorized');
+    return true;
+}
+function parseHostnameFromHeader(header) {
+    const headerValue = Array.isArray(header) ? header[0] : header;
+    if (!headerValue || headerValue === 'null') {
+        return;
+    }
+    const parsedHeader = (0, _url.parseUrl)(headerValue);
+    return parsedHeader == null ? void 0 : parsedHeader.hostname.toLowerCase();
+}
+function isInternalEndpoint(req) {
+    if (!req.url) return false;
+    try {
+        // TODO: We should standardize on a single prefix for this
+        const isMiddlewareRequest = req.url.includes('/__nextjs');
+        const isInternalAsset = req.url.includes('/_next');
+        // Static media requests are excluded, as they might be loaded via CSS and would fail
+        // CORS checks.
+        const isIgnoredRequest = req.url.includes('/_next/image') || req.url.includes('/_next/static/media');
+        return !isIgnoredRequest && (isInternalAsset || isMiddlewareRequest);
+    } catch (err) {
+        return false;
+    }
+}
+const blockCrossSiteDEV = (req, res, allowedDevOrigins, hostname)=>{
+    const allowedOrigins = [
+        '*.localhost',
+        'localhost',
+        ...allowedDevOrigins ?? []
+    ];
+    if (hostname) {
+        allowedOrigins.push(hostname);
+    }
+    // only process internal URLs/middleware
+    if (!isInternalEndpoint(req)) {
+        return false;
+    }
+    // block non-cors request from cross-site e.g. script tag on
+    // different host
+    if (req.headers['sec-fetch-mode'] === 'no-cors' && req.headers['sec-fetch-site'] === 'cross-site') {
+        // no-cors requests do not send an Origin header, so fall back to Referer
+        // when validating configured cross-site script loads.
+        const refererHostname = parseHostnameFromHeader(req.headers['referer']);
+        if (refererHostname && (0, _csrfprotection.isCsrfOriginAllowed)(refererHostname, allowedOrigins)) {
+            return false;
+        }
+        return blockRequest(req, res, refererHostname);
+    }
+    // ensure websocket requests are only fulfilled from allowed origin
+    const rawOrigin = req.headers['origin'];
+    const originHeader = Array.isArray(rawOrigin) ? rawOrigin[0] : rawOrigin;
+    const parsedOrigin = originHeader && originHeader !== 'null' ? (0, _url.parseUrl)(originHeader) : originHeader;
+    const originLowerCase = parsedOrigin === undefined || typeof parsedOrigin === 'string' ? parsedOrigin : parsedOrigin.hostname.toLowerCase();
+    // Allow requests with no origin since those are just GET requests from same-site
+    return originLowerCase !== undefined && !(0, _csrfprotection.isCsrfOriginAllowed)(originLowerCase, allowedOrigins) && blockRequest(req, res, originLowerCase);
+};
+
+//# sourceMappingURL=block-cross-site-dev.js.map

package/assets/standalone/node_modules/next/dist/server/lib/router-utils/filesystem.js

@@ -119,7 +119,10 @@ const buildCustomRoute = (type, item, basePath, caseSensitive)=>{
 };
 async function setupFsCheck(opts) {
     const getItemsLru = !opts.dev ? new _lrucache.LRUCache(1024 * 1024, function length(value) {
-        if (!value) return 0;
+        if (!value) {
+            // Null entries (negative cache) still need a non-zero size for LRU eviction
+            return 1;
+        }
         return (value.fsPath || '').length + value.itemPath.length + value.type.length;
     }) : undefined;
     // routes that have _next/data endpoints (SSG/SSP)
@@ -151,10 +154,11 @@ async function setupFsCheck(opts) {
             afterFiles: [],
             fallback: []
         },
+        onMatchHeaders: [],
         headers: []
     };
     let buildId = 'development';
-    let prerenderManifest;
+    let previewProps;
     if (!opts.dev) {
         var _middlewareManifest_middleware_, _middlewareManifest_middleware;
         const buildIdPath = _path.default.join(opts.dir, opts.config.distDir, _constants.BUILD_ID_FILE);
@@ -204,7 +208,7 @@ async function setupFsCheck(opts) {
         const pagesManifestPath = _path.default.join(distDir, 'server', _constants.PAGES_MANIFEST);
         const appRoutesManifestPath = _path.default.join(distDir, _constants.APP_PATH_ROUTES_MANIFEST);
         const routesManifest = JSON.parse(await _promises.default.readFile(routesManifestPath, 'utf8'));
-        prerenderManifest = JSON.parse(await _promises.default.readFile(prerenderManifestPath, 'utf8'));
+        previewProps = JSON.parse(await _promises.default.readFile(prerenderManifestPath, 'utf8')).preview;
         const middlewareManifest = JSON.parse(await _promises.default.readFile(middlewareManifestPath, 'utf8').catch(()=>'{}'));
         const functionsConfigManifest = JSON.parse(await _promises.default.readFile(functionsConfigManifestPath, 'utf8').catch(()=>'{}'));
         const pagesManifest = JSON.parse(await _promises.default.readFile(pagesManifestPath, 'utf8'));
@@ -274,24 +278,20 @@ async function setupFsCheck(opts) {
                 afterFiles: [],
                 fallback: []
             },
-            headers: routesManifest.headers
+            headers: routesManifest.headers,
+            onMatchHeaders: routesManifest.onMatchHeaders
         };
     } else {
         // dev handling
         customRoutes = await (0, _loadcustomroutes.default)(opts.config);
-        prerenderManifest = {
-            version: 4,
-            routes: {},
-            dynamicRoutes: {},
-            notFoundRoutes: [],
-            preview: {
-                previewModeId: require('crypto').randomBytes(16).toString('hex'),
-                previewModeSigningKey: require('crypto').randomBytes(32).toString('hex'),
-                previewModeEncryptionKey: require('crypto').randomBytes(32).toString('hex')
-            }
+        previewProps = {
+            previewModeId: require('crypto').randomBytes(16).toString('hex'),
+            previewModeSigningKey: require('crypto').randomBytes(32).toString('hex'),
+            previewModeEncryptionKey: require('crypto').randomBytes(32).toString('hex')
         };
     }
     const headers = customRoutes.headers.map((item)=>buildCustomRoute('header', item, opts.config.basePath, opts.config.experimental.caseSensitiveRoutes));
+    const onMatchHeaders = customRoutes.onMatchHeaders.map((item)=>buildCustomRoute('header', item, opts.config.basePath, opts.config.experimental.caseSensitiveRoutes));
     const redirects = customRoutes.redirects.map((item)=>buildCustomRoute('redirect', item, opts.config.basePath, opts.config.experimental.caseSensitiveRoutes));
     const rewrites = {
         beforeFiles: customRoutes.rewrites.beforeFiles.map((item)=>buildCustomRoute('before_files_rewrite', item)),
@@ -326,6 +326,7 @@ async function setupFsCheck(opts) {
     };
     return {
         headers,
+        onMatchHeaders,
         rewrites,
         redirects,
         buildId,
@@ -337,7 +338,7 @@ async function setupFsCheck(opts) {
         nextDataRoutes,
         exportPathMapRoutes: undefined,
         devVirtualFsItems: new Set(),
-        prerenderManifest,
+        previewProps,
         middlewareMatcher: middlewareMatcher,
         ensureCallback (fn) {
             ensureFn = fn;

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

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "getResolveRoutes", {
         return getResolveRoutes;
     }
 });
-const _url = /*#__PURE__*/ _interop_require_default(require("url"));
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
 const _bodystreams = require("../../body-streams");
@@ -23,6 +22,7 @@ const _utils2 = require("../../../shared/lib/utils");
 const _relativizeurl = require("../../../shared/lib/router/utils/relativize-url");
 const _addpathprefix = require("../../../shared/lib/router/utils/add-path-prefix");
 const _pathhasprefix = require("../../../shared/lib/router/utils/path-has-prefix");
+const _parseurl = require("../../../shared/lib/router/utils/parse-url");
 const _detectdomainlocale = require("../../../shared/lib/i18n/detect-domain-locale");
 const _normalizelocalepath = require("../../../shared/lib/i18n/normalize-locale-path");
 const _removepathprefix = require("../../../shared/lib/router/utils/remove-path-prefix");
@@ -38,6 +38,12 @@ function _interop_require_default(obj) {
 }
 const debug = (0, _debug.default)('next:router-server:resolve-routes');
 function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpts, ensureMiddleware) {
+    let clientHashes = undefined;
+    if (process.env.__NEXT_TEST_MODE && process.env.IS_TURBOPACK_TEST) {
+        try {
+            clientHashes = JSON.parse(require('fs').readFileSync(_nodepath.default.join(opts.dir, config.distDir, 'immutable-static-hashes.json'), 'utf8'));
+        } catch  {}
+    }
     let routes = null;
     const calculateRoutes = ()=>{
         return [
@@ -81,7 +87,7 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
         let finished = false;
         let resHeaders = {};
         let matchedOutput = null;
-        let parsedUrl = _url.default.parse(req.url || '', true);
+        let parsedUrl = (0, _parseurl.parseUrl)(req.url || '');
         let didRewrite = false;
         const urlParts = (req.url || '').split('?', 1);
         const urlNoQuery = urlParts[0];
@@ -96,7 +102,7 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
         // handle trailing slash as that is handled the same as a next.config.js
         // redirect
         if (urlNoQuery == null ? void 0 : urlNoQuery.match(/(\\|\/\/)/)) {
-            parsedUrl = _url.default.parse((0, _utils2.normalizeRepeatedSlashes)(req.url), true);
+            parsedUrl = (0, _parseurl.parseUrl)((0, _utils2.normalizeRepeatedSlashes)(req.url));
             return {
                 parsedUrl,
                 resHeaders,
@@ -288,6 +294,19 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                             if (output.locale) {
                                 (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;
+                                if (parsedUrl.query.dpl !== expectedToken) {
+                                    console.error(`Invalid dpl query param: ${req.url}, expected: ${expectedToken}`);
+                                    return {
+                                        finished: true,
+                                        parsedUrl,
+                                        resHeaders,
+                                        matchedOutput: null
+                                    };
+                                }
+                            }
                             return {
                                 parsedUrl,
                                 resHeaders,
@@ -431,7 +450,7 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                             const value = middlewareHeaders['x-middleware-rewrite'];
                             const destination = (0, _relativizeurl.getRelativeURL)(value, initUrl);
                             resHeaders['x-middleware-rewrite'] = destination;
-                            parsedUrl = _url.default.parse(destination, true);
+                            parsedUrl = (0, _parseurl.parseUrl)(destination);
                             if (parsedUrl.protocol) {
                                 return {
                                     parsedUrl,
@@ -455,7 +474,7 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                                 // Process as redirect: update parsedUrl and convert to relative URL
                                 const rel = (0, _relativizeurl.getRelativeURL)(value, initUrl);
                                 resHeaders['location'] = rel;
-                                parsedUrl = _url.default.parse(rel, true);
+                                parsedUrl = (0, _parseurl.parseUrl)(rel);
                                 return {
                                     parsedUrl,
                                     resHeaders,
@@ -497,11 +516,9 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                     delete parsedDestination.query;
                     parsedDestination.search = (0, _serverrouteutils.stringifyQuery)(req, query);
                     parsedDestination.pathname = (0, _utils2.normalizeRepeatedSlashes)(parsedDestination.pathname);
-                    // @ts-expect-error // custom ParsedUrl
-                    const unsafeParsedUrl = parsedDestination;
                     return {
                         finished: true,
-                        parsedUrl: unsafeParsedUrl,
+                        parsedUrl: parsedDestination,
                         resHeaders: null,
                         statusCode: (0, _redirectstatus.getRedirectStatus)(route)
                     };
@@ -557,10 +574,8 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                         }
                     }
                     if (parsedDestination.protocol) {
-                        // @ts-expect-error // custom ParsedUrl
-                        const unsafeParsedUrl = parsedDestination;
                         return {
-                            parsedUrl: unsafeParsedUrl,
+                            parsedUrl: parsedDestination,
                             resHeaders: null,
                             finished: true
                         };
@@ -592,6 +607,12 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
         for (const route of routes){
             const result = await handleRoute(route);
             if (result) {
+                if (result.matchedOutput) {
+                    // handle onMatchHeaders
+                    for (const onMatchHeaders of fsChecker.onMatchHeaders){
+                        await handleRoute(onMatchHeaders);
+                    }
+                }
                 return result;
             }
         }

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

@@ -266,21 +266,21 @@ async function writeRouteTypesManifest(manifest, filePath, config) {
         });
     }
     // Write the main routes.d.ts file
-    await _fs.default.promises.writeFile(filePath, (0, _typegen.generateRouteTypesFile)(manifest));
+    await _fs.default.promises.writeFile(filePath, config.experimental.strictRouteTypes ? (0, _typegen.generateRouteTypesFileStrict)(manifest) : (0, _typegen.generateRouteTypesFile)(manifest));
     // Write the link.d.ts file if typedRoutes is enabled
     if (config.typedRoutes === true) {
         const linkTypesPath = _path.default.join(dirname, 'link.d.ts');
         await _fs.default.promises.writeFile(linkTypesPath, (0, _typegen.generateLinkTypesFile)(manifest));
     }
 }
-async function writeValidatorFile(manifest, filePath) {
+async function writeValidatorFile(manifest, filePath, strict) {
     const dirname = _path.default.dirname(filePath);
     if (!_fs.default.existsSync(dirname)) {
         await _fs.default.promises.mkdir(dirname, {
             recursive: true
         });
     }
-    await _fs.default.promises.writeFile(filePath, (0, _typegen.generateValidatorFile)(manifest));
+    await _fs.default.promises.writeFile(filePath, strict ? (0, _typegen.generateValidatorFileStrict)(manifest) : (0, _typegen.generateValidatorFile)(manifest));
 }
 
 //# sourceMappingURL=route-types-utils.js.map

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

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     generateLinkTypesFile: null,
     generateRouteTypesFile: null,
-    generateValidatorFile: null
+    generateRouteTypesFileStrict: null,
+    generateValidatorFile: null,
+    generateValidatorFileStrict: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -20,8 +22,14 @@ _export(exports, {
     generateRouteTypesFile: function() {
         return generateRouteTypesFile;
     },
+    generateRouteTypesFileStrict: function() {
+        return generateRouteTypesFileStrict;
+    },
     generateValidatorFile: function() {
         return generateValidatorFile;
+    },
+    generateValidatorFileStrict: function() {
+        return generateValidatorFileStrict;
     }
 });
 const _isdynamic = require("../../../shared/lib/router/utils/is-dynamic");
@@ -472,7 +480,7 @@ function generateValidatorFile(routesManifest) {
   default: (req: any, res: any) => ReturnType<NextApiHandler>
   config?: {
     api?: {
-      bodyParser?: boolean | { sizeLimit?: string }
+      bodyParser?: boolean | { sizeLimit?: number | string }
       responseLimit?: string | number | boolean
       externalResolver?: boolean
     }
@@ -526,6 +534,162 @@ ${pagesRouterPageValidations}
 
 ${pagesApiRouteValidations}
 
+${layoutValidations}
+`;
+}
+function generateValidatorFileStrict(routesManifest) {
+    const generateValidations = (paths, type, pathToRouteMap)=>paths.sort()// Only validate TypeScript files - JavaScript files have too many type inference limitations
+        .filter((filePath)=>filePath.endsWith('.ts') || filePath.endsWith('.tsx')).filter(// Don't include metadata routes or pages
+        // (e.g. /manifest.webmanifest)
+        (filePath)=>type !== 'AppPageConfig' || filePath.endsWith('page.ts') || filePath.endsWith('page.tsx')).map((filePath)=>{
+            // Keep the file extension for TypeScript imports to support node16 module resolution
+            const importPath = filePath;
+            const route = pathToRouteMap == null ? void 0 : pathToRouteMap.get(filePath);
+            const typeWithRoute = route && (type === 'AppPageConfig' || type === 'LayoutConfig' || type === 'RouteHandlerConfig') ? `${type}<${JSON.stringify(route)}>` : type;
+            return `// Validate ${filePath}
+{
+  const handler = {} as typeof import(${JSON.stringify(importPath.replace(/\.tsx?$/, '.js'))})
+  handler satisfies ${typeWithRoute}
+}`;
+        }).join('\n\n');
+    // Use direct mappings from the manifest
+    // Generate validations for different route types
+    const appPageValidations = generateValidations(Array.from(routesManifest.appPagePaths).sort(), 'AppPageConfig', routesManifest.filePathToRoute);
+    const appRouteHandlerValidations = generateValidations(Array.from(routesManifest.appRouteHandlers).sort(), 'RouteHandlerConfig', routesManifest.filePathToRoute);
+    const pagesRouterPageValidations = generateValidations(Array.from(routesManifest.pagesRouterPagePaths).sort(), 'PagesPageConfig');
+    const pagesApiRouteValidations = generateValidations(Array.from(routesManifest.pageApiRoutes).sort(), 'ApiRouteConfig');
+    const layoutValidations = generateValidations(Array.from(routesManifest.layoutPaths).sort(), 'LayoutConfig', routesManifest.filePathToRoute);
+    const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
+    // Build type definitions based on what's actually used
+    let typeDefinitions = '';
+    if (appPageValidations) {
+        typeDefinitions += `type AppPageConfig<Route extends AppRoutes = AppRoutes> = {
+  default: React.JSXElementConstructor<PageProps<Route>>
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: PageProps<Route>,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: PageProps<Route>,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`;
+    }
+    if (pagesRouterPageValidations) {
+        typeDefinitions += `type PagesPageConfig = {
+  default: React.ComponentType<any> | ((props: any) => React.ReactNode | Promise<React.ReactNode> | never | void)
+  getStaticProps?: (context: any) => Promise<any> | any
+  getStaticPaths?: (context: any) => Promise<any> | any
+  getServerSideProps?: (context: any) => Promise<any> | any
+  getInitialProps?: (context: any) => Promise<any> | any
+  /**
+   * Segment configuration for legacy Pages Router pages.
+   * Validated at build-time by parsePagesSegmentConfig.
+   */
+  config?: {
+    maxDuration?: number
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    regions?: string[]
+  }
+}
+
+`;
+    }
+    if (layoutValidations) {
+        typeDefinitions += `type LayoutConfig<Route extends LayoutRoutes = LayoutRoutes> = {
+  default: React.ComponentType<LayoutProps<Route>> | ((props: LayoutProps<Route>) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`;
+    }
+    if (appRouteHandlerValidations) {
+        typeDefinitions += `type RouteHandlerConfig<Route extends AppRouteHandlerRoutes = AppRouteHandlerRoutes> = {
+  GET?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  POST?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PUT?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PATCH?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  DELETE?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  HEAD?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  OPTIONS?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+}
+
+`;
+    }
+    if (pagesApiRouteValidations) {
+        typeDefinitions += `type ApiRouteConfig = {
+  default: (req: any, res: any) => ReturnType<NextApiHandler>
+  config?: {
+    api?: {
+      bodyParser?: boolean | { sizeLimit?: number | string }
+      responseLimit?: string | number | boolean
+      externalResolver?: boolean
+    }
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    maxDuration?: number
+  }
+}
+
+`;
+    }
+    // Build import statement based on what's actually needed
+    const routeImports = [];
+    // Only import AppRoutes if there are app pages
+    if (appPageValidations) {
+        routeImports.push('AppRoutes');
+    }
+    // Only import LayoutRoutes if there are layouts
+    if (layoutValidations) {
+        routeImports.push('LayoutRoutes');
+    }
+    // Only import ParamMap if there are routes that use it
+    if (appPageValidations || layoutValidations || appRouteHandlerValidations) {
+        routeImports.push('ParamMap');
+    }
+    if (hasAppRouteHandlers) {
+        routeImports.push('AppRouteHandlerRoutes');
+    }
+    const routeImportStatement = routeImports.length > 0 ? `import type { ${routeImports.join(', ')} } from "./routes.js"` : '';
+    const nextRequestImport = hasAppRouteHandlers ? "import type { NextRequest } from 'next/server.js'\n" : '';
+    // Conditionally import types from next/types, merged into a single statement
+    const nextTypes = [];
+    if (pagesApiRouteValidations) {
+        nextTypes.push('NextApiHandler');
+    }
+    if (appPageValidations || layoutValidations) {
+        nextTypes.push('ResolvingMetadata', 'ResolvingViewport');
+    }
+    const nextTypesImport = nextTypes.length > 0 ? `import type { ${nextTypes.join(', ')} } from "next/types.js"\n` : '';
+    return `// This file is generated automatically by Next.js with experimental.strictRouteTypes
+// Do not edit this file manually
+// This file validates that all pages and layouts export the correct types
+
+${routeImportStatement}
+${nextTypesImport}${nextRequestImport}
+${typeDefinitions}
+${appPageValidations}
+
+${appRouteHandlerValidations}
+
+${pagesRouterPageValidations}
+
+${pagesApiRouteValidations}
+
 ${layoutValidations}
 `;
 }
@@ -575,6 +739,87 @@ ${layoutSlotMap}
 
 ${exportStatement}
 
+declare global {
+  /**
+   * Props for Next.js App Router page components
+   * @example
+   * \`\`\`tsx
+   * export default function Page(props: PageProps<'/blog/[slug]'>) {
+   *   const { slug } = await props.params
+   *   return <div>Blog post: {slug}</div>
+   * }
+   * \`\`\`
+   */
+  interface PageProps<AppRoute extends AppRoutes> {
+    params: Promise<ParamMap[AppRoute]>
+    searchParams: Promise<Record<string, string | string[] | undefined>>
+  }
+
+  /**
+   * Props for Next.js App Router layout components
+   * @example
+   * \`\`\`tsx
+   * export default function Layout(props: LayoutProps<'/dashboard'>) {
+   *   return <div>{props.children}</div>
+   * }
+   * \`\`\`
+   */
+  type LayoutProps<LayoutRoute extends LayoutRoutes> = {
+    params: Promise<ParamMap[LayoutRoute]>
+    children: React.ReactNode
+  } & {
+    [K in LayoutSlotMap[LayoutRoute]]: React.ReactNode
+  }${routeContextInterface}
+}
+`;
+}
+function generateRouteTypesFileStrict(routesManifest) {
+    const routeTypes = generateRouteTypes(routesManifest);
+    const paramTypes = generateParamTypes(routesManifest);
+    const layoutSlotMap = generateLayoutSlotMap(routesManifest);
+    const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
+    // Build export statement based on what's actually generated
+    const routeExports = [
+        'AppRoutes',
+        'PageProps',
+        'PageRoutes',
+        'LayoutRoutes',
+        'RedirectRoutes',
+        'RewriteRoutes',
+        'ParamMap'
+    ];
+    if (hasAppRouteHandlers) {
+        routeExports.push('AppRouteHandlerRoutes');
+    }
+    const exportStatement = `export type { ${routeExports.join(', ')} }`;
+    const routeContextInterface = hasAppRouteHandlers ? `
+
+  /**
+   * Context for Next.js App Router route handlers
+   * @example
+   * \`\`\`tsx
+   * export async function GET(request: NextRequest, context: RouteContext<'/api/users/[id]'>) {
+   *   const { id } = await context.params
+   *   return Response.json({ id })
+   * }
+   * \`\`\`
+   */
+  interface RouteContext<AppRouteHandlerRoute extends AppRouteHandlerRoutes> {
+    params: Promise<ParamMap[AppRouteHandlerRoute]>
+  }` : '';
+    return `// This file is generated automatically by Next.js with experimental.strictRouteTypes
+// Do not edit this file manually
+
+${routeTypes}
+
+${paramTypes}
+
+export type ParamsOf<Route extends Routes> = ParamMap[Route]
+
+${layoutSlotMap}
+
+${exportStatement}
+
 declare global {
   /**
    * Props for Next.js App Router page components

package/assets/standalone/node_modules/next/dist/server/lib/server-ipc/utils.js

@@ -67,7 +67,8 @@ const INTERNAL_HEADERS = [
     'x-middleware-override-headers',
     'x-middleware-next',
     'x-now-route-matches',
-    'x-matched-path'
+    'x-matched-path',
+    'x-next-resume-state-length'
 ];
 const filterInternalHeaders = (headers)=>{
     for(const header in headers){