gsd-pi 2.67.0-dev.43b0159 → 2.67.0-dev.a5b1d8f

package/dist/web/standalone/node_modules/next/dist/lib/load-custom-routes.js

@@ -29,6 +29,7 @@ const _escaperegexp = require("../shared/lib/escape-regexp");
 const _trytoparsepath = require("./try-to-parse-path");
 const _redirectstatus = require("./redirect-status");
 const _url = require("./url");
+const _constants = require("./constants");
 const allowedHasTypes = new Set([
     'header',
     'cookie',
@@ -461,24 +462,66 @@ async function loadHeaders(config) {
     return headers;
 }
 async function loadCustomRoutes(config) {
-    var _config_experimental;
     const [headers, rewrites, redirects] = await Promise.all([
         loadHeaders(config),
         loadRewrites(config),
         loadRedirects(config)
     ]);
+    const onMatchHeaders = [];
     const totalRewrites = rewrites.beforeFiles.length + rewrites.afterFiles.length + rewrites.fallback.length;
     const totalRoutes = headers.length + redirects.length + totalRewrites;
     if (totalRoutes > 1000) {
         console.warn((0, _picocolors.bold)((0, _picocolors.yellow)(`Warning: `)) + `total number of custom routes exceeds 1000, this can reduce performance. Route counts:\n` + `headers: ${headers.length}\n` + `rewrites: ${totalRewrites}\n` + `redirects: ${redirects.length}\n` + `See more info: https://nextjs.org/docs/messages/max-custom-routes-reached`);
     }
-    if (((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) && config.deploymentId) {
-        headers.unshift({
+    const cacheControlSources = [];
+    for (const headerRoute of headers){
+        if (!headerRoute.source.startsWith('/_next/')) {
+            continue;
+        }
+        for (const header of headerRoute.headers){
+            if (header.key.toLowerCase() === 'cache-control') {
+                cacheControlSources.push(headerRoute.source);
+                break;
+            }
+        }
+    }
+    if (cacheControlSources.length > 0) {
+        console.warn((0, _picocolors.bold)((0, _picocolors.yellow)(`Warning: `)) + `Custom Cache-Control headers detected for the following routes:\n` + cacheControlSources.map((source)=>`  - ${source}`).join('\n') + `\n\nSetting a custom Cache-Control header can break Next.js development behavior.`);
+    }
+    if (config.deploymentId) {
+        var _config_experimental;
+        if ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) {
+            headers.unshift({
+                source: '/:path*',
+                headers: [
+                    {
+                        key: 'Set-Cookie',
+                        value: `__vdpl=${config.deploymentId}; Path=/; HttpOnly`
+                    }
+                ]
+            });
+        }
+        onMatchHeaders.push({
             source: '/:path*',
+            has: [
+                {
+                    type: 'header',
+                    key: 'rsc',
+                    value: '1'
+                }
+            ],
+            headers: [
+                {
+                    key: _constants.NEXT_NAV_DEPLOYMENT_ID_HEADER,
+                    value: config.deploymentId
+                }
+            ]
+        }, {
+            source: '/_next/data/(.*)',
             headers: [
                 {
-                    key: 'Set-Cookie',
-                    value: `__vdpl=${config.deploymentId}; Path=/; HttpOnly`
+                    key: _constants.NEXT_NAV_DEPLOYMENT_ID_HEADER,
+                    value: config.deploymentId
                 }
             ]
         });
@@ -542,6 +585,7 @@ async function loadCustomRoutes(config) {
     }
     return {
         headers,
+        onMatchHeaders,
         rewrites,
         redirects
     };

package/dist/web/standalone/node_modules/next/dist/lib/memory/trace.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getAllMemoryUsageSpans: null,
+    startPeriodicMemoryUsageTracing: null,
+    stopPeriodicMemoryUsageTracing: null,
+    traceMemoryUsage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getAllMemoryUsageSpans: function() {
+        return getAllMemoryUsageSpans;
+    },
+    startPeriodicMemoryUsageTracing: function() {
+        return startPeriodicMemoryUsageTracing;
+    },
+    stopPeriodicMemoryUsageTracing: function() {
+        return stopPeriodicMemoryUsageTracing;
+    },
+    traceMemoryUsage: function() {
+        return traceMemoryUsage;
+    }
+});
+const _v8 = /*#__PURE__*/ _interop_require_default(require("v8"));
+const _log = require("../../build/output/log");
+const _trace = require("../../trace");
+const _picocolors = require("../picocolors");
+const _path = require("path");
+const _shared = require("../../trace/shared");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const HEAP_SNAPSHOT_THRESHOLD_PERCENT = 70;
+let alreadyGeneratedHeapSnapshot = false;
+const TRACE_MEMORY_USAGE_TIMER_MS = 20000;
+let traceMemoryUsageTimer;
+const allMemoryUsage = [];
+function startPeriodicMemoryUsageTracing() {
+    traceMemoryUsageTimer = setTimeout(()=>{
+        traceMemoryUsage('periodic memory snapshot');
+        startPeriodicMemoryUsageTracing();
+    }, TRACE_MEMORY_USAGE_TIMER_MS);
+}
+function stopPeriodicMemoryUsageTracing() {
+    if (traceMemoryUsageTimer) {
+        clearTimeout(traceMemoryUsageTimer);
+    }
+}
+function getAllMemoryUsageSpans() {
+    return allMemoryUsage;
+}
+function traceMemoryUsage(description, parentSpan) {
+    const memoryUsage = process.memoryUsage();
+    const v8HeapStatistics = _v8.default.getHeapStatistics();
+    const heapUsed = v8HeapStatistics.used_heap_size;
+    const heapMax = v8HeapStatistics.heap_size_limit;
+    const tracedMemoryUsage = {
+        'memory.rss': memoryUsage.rss,
+        'memory.heapUsed': heapUsed,
+        'memory.heapTotal': memoryUsage.heapTotal,
+        'memory.heapMax': heapMax
+    };
+    allMemoryUsage.push(tracedMemoryUsage);
+    const tracedMemoryUsageAsStrings = Object.fromEntries(Object.entries(tracedMemoryUsage).map(([key, value])=>[
+            key,
+            String(value)
+        ]));
+    if (parentSpan) {
+        parentSpan.traceChild('memory-usage', tracedMemoryUsageAsStrings);
+    } else {
+        (0, _trace.trace)('memory-usage', undefined, tracedMemoryUsageAsStrings);
+    }
+    if (process.env.EXPERIMENTAL_DEBUG_MEMORY_USAGE) {
+        const percentageHeapUsed = 100 * heapUsed / heapMax;
+        (0, _log.info)('');
+        (0, _log.info)('***************************************');
+        (0, _log.info)(`Memory usage report at "${description}":`);
+        (0, _log.info)(` - RSS: ${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`);
+        (0, _log.info)(` - Heap Used: ${(heapUsed / 1024 / 1024).toFixed(2)} MB`);
+        (0, _log.info)(` - Heap Total Allocated: ${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`);
+        (0, _log.info)(` - Heap Max: ${(heapMax / 1024 / 1024).toFixed(2)} MB`);
+        (0, _log.info)(` - Percentage Heap Used: ${percentageHeapUsed.toFixed(2)}%`);
+        (0, _log.info)('***************************************');
+        (0, _log.info)('');
+        if (percentageHeapUsed > HEAP_SNAPSHOT_THRESHOLD_PERCENT) {
+            const distDir = _shared.traceGlobals.get('distDir');
+            const heapFilename = (0, _path.join)(distDir, `${description.replace(' ', '-')}.heapsnapshot`);
+            (0, _log.warn)((0, _picocolors.bold)(`Heap usage is close to the limit. ${percentageHeapUsed.toFixed(2)}% of heap has been used.`));
+            if (!alreadyGeneratedHeapSnapshot) {
+                (0, _log.warn)((0, _picocolors.bold)(`Saving heap snapshot to ${heapFilename}.  ${(0, _picocolors.italic)('Note: this will take some time.')}`));
+                _v8.default.writeHeapSnapshot(heapFilename);
+                alreadyGeneratedHeapSnapshot = true;
+            } else {
+                (0, _log.warn)('Skipping heap snapshot generation since heap snapshot has already been generated.');
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=trace.js.map

package/dist/web/standalone/node_modules/next/dist/lib/metadata/get-metadata-route.js

@@ -70,12 +70,21 @@ function _interop_require_default(obj) {
     }
     return suffix;
 }
-function fillMetadataSegment(segment, params, lastSegment) {
+function fillMetadataSegment(segment, params, lastSegment, isStatic) {
     const pathname = (0, _apppaths.normalizeAppPath)(segment);
     const routeRegex = (0, _routeregex.getNamedRouteRegex)(pathname, {
         prefixRouteKeys: false
     });
-    const route = (0, _serverutils.interpolateDynamicPath)(pathname, params, routeRegex);
+    // For static metadata files, fill all dynamic segments with "-" placeholder
+    const routeParams = isStatic ? Object.keys(routeRegex.groups).reduce((acc, key)=>{
+        const { repeat } = routeRegex.groups[key];
+        // Use array for catch-all segments, string for regular segments
+        acc[key] = repeat ? [
+            '-'
+        ] : '-';
+        return acc;
+    }, {}) : params;
+    const route = (0, _serverutils.interpolateDynamicPath)(pathname, routeParams, routeRegex);
     const { name, ext } = _path.default.parse(lastSegment);
     const pagePath = _path.default.posix.join(segment, name);
     const suffix = getMetadataRouteSuffix(pagePath);

package/dist/web/standalone/node_modules/next/dist/lib/needs-experimental-react.js

@@ -9,8 +9,8 @@ Object.defineProperty(exports, "needsExperimentalReact", {
     }
 });
 function needsExperimentalReact(config) {
-    const { taint, transitionIndicator } = config.experimental || {};
-    return Boolean(taint || transitionIndicator);
+    const { taint, transitionIndicator, gestureTransition } = config.experimental || {};
+    return Boolean(taint || transitionIndicator || gestureTransition);
 }
 
 //# sourceMappingURL=needs-experimental-react.js.map

package/dist/web/standalone/node_modules/next/dist/lib/patch-incorrect-lockfile.js

@@ -11,7 +11,7 @@ Object.defineProperty(exports, "patchIncorrectLockfile", {
 const _fs = require("fs");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
 const _findup = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/find-up"));
-const _packagejson = /*#__PURE__*/ _interop_require_default(require("next/package.json"));
+const _packagejson = require("next/package.json");
 const _ciinfo = require("../server/ci-info");
 const _getregistry = require("./helpers/get-registry");
 function _interop_require_default(obj) {
@@ -72,7 +72,7 @@ async function fetchPkgInfo(pkg) {
         });
     }
     const data = await res.json();
-    const versionData = data.versions[_packagejson.default.version];
+    const versionData = data.versions["16.2.3"];
     return {
         os: versionData.os,
         cpu: versionData.cpu,
@@ -97,10 +97,10 @@ async function patchIncorrectLockfile(dir) {
     const endingNewline = content.endsWith('\r\n') ? '\r\n' : content.endsWith('\n') ? '\n' : '';
     const lockfileParsed = JSON.parse(content);
     const lockfileVersion = parseInt(lockfileParsed == null ? void 0 : lockfileParsed.lockfileVersion, 10);
-    const expectedSwcPkgs = Object.keys(_packagejson.default['optionalDependencies'] || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
+    const expectedSwcPkgs = Object.keys(_packagejson.optionalDependencies || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
     const patchDependency = (pkg, pkgData)=>{
         lockfileParsed.dependencies[pkg] = {
-            version: _packagejson.default.version,
+            version: "16.2.3",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             optional: true
@@ -108,7 +108,7 @@ async function patchIncorrectLockfile(dir) {
     };
     const patchPackage = (pkg, pkgData)=>{
         lockfileParsed.packages[pkg] = {
-            version: _packagejson.default.version,
+            version: "16.2.3",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             cpu: pkgData.cpu,

package/dist/web/standalone/node_modules/next/dist/lib/try-to-parse-path.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "tryToParsePath", {
     }
 });
 const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
-const _url = require("url");
 const _iserror = /*#__PURE__*/ _interop_require_default(require("./is-error"));
 const _routepatternnormalizer = require("./route-pattern-normalizer");
 function _interop_require_default(obj) {
@@ -50,7 +49,7 @@ function tryToParsePath(route, options) {
     };
     try {
         if (options == null ? void 0 : options.handleUrl) {
-            const parsed = (0, _url.parse)(route, true);
+            const parsed = new URL(route, 'http://n');
             result.parsedPath = `${parsed.pathname}${parsed.hash || ''}`;
         }
         result.tokens = (0, _pathtoregexp.parse)(result.parsedPath);

package/dist/web/standalone/node_modules/next/dist/lib/turbopack-warning.js

@@ -75,7 +75,6 @@ const unsupportedTurbopackNextConfigOptions = [
     'experimental.allowedRevalidateHeaderKeys',
     'experimental.extensionAlias',
     'experimental.fallbackNodePolyfills',
-    'experimental.sri.algorithm',
     'experimental.swcTraceProfiling',
     // Left to be implemented (Might not be needed for Turbopack)
     'experimental.craCompat',

package/dist/web/standalone/node_modules/next/dist/lib/typescript/diagnosticFormatter.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "getFormattedDiagnostic", {
         return getFormattedDiagnostic;
     }
 });
+const _codeframe = require("../../shared/lib/errors/code-frame");
 const _picocolors = require("../picocolors");
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 function _interop_require_default(obj) {
@@ -214,7 +215,6 @@ function getFormattedDiagnostic(ts, baseDir, distDir, diagnostic, isAppDirEnable
     }
     message += reason + '\n';
     if (!isLayoutOrPageError && diagnostic.file) {
-        const { codeFrameColumns } = require('next/dist/compiled/babel/code-frame');
         const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
         const line = pos.line + 1;
         const character = pos.character + 1;
@@ -223,14 +223,17 @@ function getFormattedDiagnostic(ts, baseDir, distDir, diagnostic, isAppDirEnable
             fileName = './' + fileName;
         }
         message = (0, _picocolors.cyan)(fileName) + ':' + (0, _picocolors.yellow)(line.toString()) + ':' + (0, _picocolors.yellow)(character.toString()) + '\n' + message;
-        message += '\n' + codeFrameColumns(diagnostic.file.getFullText(diagnostic.file.getSourceFile()), {
+        const codeFrame = (0, _codeframe.codeFrameColumns)(diagnostic.file.getFullText(diagnostic.file.getSourceFile()), {
             start: {
                 line: line,
                 column: character
             }
         }, {
-            forceColor: true
+            color: true
         });
+        if (codeFrame) {
+            message += '\n' + codeFrame;
+        }
     } else if (isLayoutOrPageError && appPath) {
         message = (0, _picocolors.cyan)(appPath) + '\n' + message;
     }

package/dist/web/standalone/node_modules/next/dist/lib/typescript/getTypeScriptConfiguration.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "getTypeScriptConfiguration", {
 const _picocolors = require("../picocolors");
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _semver = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/semver"));
 const _fatalerror = require("../fatal-error");
 const _iserror = /*#__PURE__*/ _interop_require_default(require("../is-error"));
 function _interop_require_default(obj) {
@@ -18,6 +19,41 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+function resolvePathAliasTarget(baseUrl, target) {
+    if (_path.default.isAbsolute(target) || target.startsWith('./') || target.startsWith('../')) {
+        return target;
+    }
+    if (baseUrl === '.' || baseUrl === './') {
+        return `./${target}`;
+    }
+    const resolvedTarget = _path.default.join(baseUrl, target);
+    if (_path.default.isAbsolute(resolvedTarget) || resolvedTarget.startsWith('./') || resolvedTarget.startsWith('../')) {
+        return resolvedTarget;
+    }
+    return `./${resolvedTarget}`;
+}
+function rewritePathAliasesWithoutBaseUrl(baseUrl, originalPaths) {
+    const rewrittenPaths = originalPaths && typeof originalPaths === 'object' ? Object.fromEntries(Object.entries(originalPaths).map(([key, values])=>[
+            key,
+            Array.isArray(values) ? values.map((value)=>typeof value === 'string' ? resolvePathAliasTarget(baseUrl, value) : value) : values
+        ])) : {
+        '*': [
+            resolvePathAliasTarget(baseUrl, '*')
+        ]
+    };
+    if (!Object.prototype.hasOwnProperty.call(rewrittenPaths, '*')) {
+        rewrittenPaths['*'] = [
+            resolvePathAliasTarget(baseUrl, '*')
+        ];
+    }
+    return rewrittenPaths;
+}
+function getNormalizedBaseUrlForPaths(baseUrl, tsConfigPath) {
+    const tsConfigDir = _path.default.resolve(_path.default.dirname(tsConfigPath));
+    const absoluteBaseUrl = _path.default.isAbsolute(baseUrl) ? baseUrl : baseUrl.startsWith('./') || baseUrl.startsWith('../') ? _path.default.resolve(tsConfigDir, baseUrl) : _path.default.resolve(baseUrl);
+    const relativeBaseUrl = _path.default.relative(tsConfigDir, absoluteBaseUrl);
+    return relativeBaseUrl || '.';
+}
 async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
     try {
         var _result_errors;
@@ -35,6 +71,39 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
             });
         }
         let configToParse = config;
+        if (_semver.default.gte(typescript.version, '6.0.0')) {
+            var _configToParse_compilerOptions, _configToParse_compilerOptions1;
+            const target = (_configToParse_compilerOptions = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions.target;
+            if (typeof target === 'string' && (target.toLowerCase() === 'es3' || target.toLowerCase() === 'es5')) {
+                const { target: _target, ...restCompilerOptions } = configToParse.compilerOptions ?? {};
+                // TypeScript 6 deprecates ES3/ES5 targets. Rewrite deprecated
+                // targets in-memory to keep typechecking working without requiring
+                // `ignoreDeprecations`.
+                configToParse = {
+                    ...configToParse,
+                    compilerOptions: {
+                        ...restCompilerOptions,
+                        target: 'es2015'
+                    }
+                };
+            }
+            const baseUrl = (_configToParse_compilerOptions1 = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions1.baseUrl;
+            const hasBaseUrl = typeof baseUrl === 'string' && baseUrl.length > 0;
+            if (hasBaseUrl) {
+                var _configToParse_compilerOptions2;
+                const rewrittenPaths = rewritePathAliasesWithoutBaseUrl(baseUrl, (_configToParse_compilerOptions2 = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions2.paths);
+                const { baseUrl: _baseUrl, ...restCompilerOptions } = configToParse.compilerOptions ?? {};
+                // TypeScript 6 deprecates `baseUrl`; rewrite aliases to explicit
+                // relative paths so path mapping still works without this option.
+                configToParse = {
+                    ...configToParse,
+                    compilerOptions: {
+                        ...restCompilerOptions,
+                        paths: rewrittenPaths
+                    }
+                };
+            }
+        }
         const result = typescript.parseJsonConfigFileContent(configToParse, // When only interested in meta info,
         // avoid enumerating all files (for performance reasons)
         metaOnly ? {
@@ -45,6 +114,17 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
                 ];
             }
         } : typescript.sys, _path.default.dirname(tsConfigPath));
+        if (_semver.default.gte(typescript.version, '6.0.0')) {
+            const parsedBaseUrl = result.options.baseUrl;
+            if (typeof parsedBaseUrl === 'string' && parsedBaseUrl.length > 0) {
+                const normalizedBaseUrl = getNormalizedBaseUrlForPaths(parsedBaseUrl, tsConfigPath);
+                // `baseUrl` can come from extended tsconfigs. Rewrite paths from the
+                // fully-resolved baseUrl and remove it so TS6 deprecation checks do not
+                // fail type checking.
+                result.options.paths = rewritePathAliasesWithoutBaseUrl(normalizedBaseUrl, result.options.paths);
+                delete result.options.baseUrl;
+            }
+        }
         if (result.errors) {
             result.errors = result.errors.filter(({ code })=>// No inputs were found in config file
                 code !== 18003);
@@ -61,7 +141,7 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
         if ((0, _iserror.default)(err) && err.name === 'SyntaxError') {
             const reason = '\n' + (err.message ?? '');
             throw Object.defineProperty(new _fatalerror.FatalError((0, _picocolors.bold)('Could not parse' + (0, _picocolors.cyan)('tsconfig.json') + '.' + ' Please make sure it contains syntactically correct JSON.') + reason), "__NEXT_ERROR_CODE", {
-                value: "E339",
+                value: "E1023",
                 enumerable: false,
                 configurable: true
             });

package/dist/web/standalone/node_modules/next/dist/lib/typescript/missingDependencyError.js

@@ -18,7 +18,7 @@ function missingDepsError(dir, missingPackages) {
     const packageManager = (0, _getpkgmanager.getPkgManager)(dir);
     const removalMsg = '\n\n' + (0, _picocolors.bold)('If you are not trying to use TypeScript, please remove the ' + (0, _picocolors.cyan)('tsconfig.json') + ' file from your package root (and any TypeScript files in your app and pages directories).');
     throw Object.defineProperty(new _fatalerror.FatalError((0, _picocolors.bold)((0, _picocolors.red)(`It looks like you're trying to use TypeScript but do not have the required package(s) installed.`)) + '\n\n' + (0, _picocolors.bold)(`Please install ${(0, _picocolors.bold)(packagesHuman)} by running:`) + '\n\n' + `\t${(0, _picocolors.bold)((0, _picocolors.cyan)((packageManager === 'yarn' ? 'yarn add --dev' : packageManager === 'pnpm' ? 'pnpm install --save-dev' : 'npm install --save-dev') + ' ' + packagesCli))}` + removalMsg + '\n'), "__NEXT_ERROR_CODE", {
-        value: "E532",
+        value: "E552",
         enumerable: false,
         configurable: true
     });

package/dist/web/standalone/node_modules/next/dist/lib/typescript/runTypeCheck.js

@@ -15,7 +15,6 @@ const _writeConfigurationDefaults = require("./writeConfigurationDefaults");
 const _typepaths = require("./type-paths");
 const _compileerror = require("../compile-error");
 const _log = require("../../build/output/log");
-const _configshared = require("../../server/config-shared");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -27,16 +26,15 @@ function _interop_require_default(obj) {
  */ function fileMatchesDebugPaths(filePath, debugPaths) {
     return debugPaths.includes(filePath);
 }
-async function runTypeCheck(typescript, baseDir, distDir, tsConfigPath, cacheDir, isAppDirEnabled, isolatedDevBuild, dirs, debugBuildPaths) {
+async function runTypeCheck(typescript, baseDir, distDir, tsConfigPath, cacheDir, isAppDirEnabled, dirs, debugBuildPaths) {
     const effectiveConfiguration = await (0, _getTypeScriptConfiguration.getTypeScriptConfiguration)(typescript, tsConfigPath);
-    // When isolatedDevBuild is enabled, tsconfig includes both .next/types and
-    // .next/dev/types to avoid config churn between dev/build modes. During build,
-    // we filter out .next/dev/types files to prevent stale dev types from causing
-    // errors when routes have been deleted since the last dev session.
+    // tsconfig includes both .next/types and .next/dev/types to avoid config churn
+    // between dev/build modes. During build, we filter out .next/dev/types files to
+    // prevent stale dev types from causing errors when routes have been deleted since
+    // the last dev session.
     let fileNames = effectiveConfiguration.fileNames;
-    const resolvedIsolatedDevBuild = isolatedDevBuild === undefined ? _configshared.defaultConfig.experimental.isolatedDevBuild : isolatedDevBuild;
     // Get the dev types path to filter (null if not applicable)
-    const devTypesDir = (0, _typepaths.getDevTypesPath)(baseDir, distDir, resolvedIsolatedDevBuild);
+    const devTypesDir = (0, _typepaths.getDevTypesPath)(baseDir, distDir);
     if (devTypesDir) {
         fileNames = fileNames.filter((fileName)=>!fileName.startsWith(devTypesDir));
     }

package/dist/web/standalone/node_modules/next/dist/lib/typescript/type-paths.js

@@ -26,24 +26,19 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-function getTypeDefinitionGlobPatterns(distDir, isolatedDevBuild) {
+function getTypeDefinitionGlobPatterns(distDir) {
     const distDirPosix = _path.default.win32.sep === _path.default.sep ? distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep) : distDir;
     const typeGlobPatterns = [
         `${distDirPosix}/types/**/*.ts`
     ];
-    // When isolatedDevBuild is enabled, include both .next/types and .next/dev/types
-    // to avoid tsconfig churn when switching between dev/build modes
-    if (isolatedDevBuild) {
-        typeGlobPatterns.push(process.env.NODE_ENV === 'development' ? `${distDirPosix.replace(/\/dev$/, '')}/types/**/*.ts` : `${distDirPosix}/dev/types/**/*.ts`);
-        // Sort for consistent order
-        typeGlobPatterns.sort((a, b)=>a.length - b.length);
-    }
+    // Include both .next/types and .next/dev/types to avoid tsconfig churn when switching
+    // between dev/build modes
+    typeGlobPatterns.push(process.env.NODE_ENV === 'development' ? `${distDirPosix.replace(/\/dev$/, '')}/types/**/*.ts` : `${distDirPosix}/dev/types/**/*.ts`);
+    // Sort for consistent order
+    typeGlobPatterns.sort((a, b)=>a.length - b.length);
     return typeGlobPatterns;
 }
-function getDevTypesPath(baseDir, distDir, isolatedDevBuild) {
-    if (!isolatedDevBuild) {
-        return null;
-    }
+function getDevTypesPath(baseDir, distDir) {
     const isDev = process.env.NODE_ENV === 'development';
     if (isDev) {
         // In dev mode, dev types are the main types, so no need to filter

package/dist/web/standalone/node_modules/next/dist/lib/typescript/writeAppTypeDeclarations.js

@@ -16,7 +16,7 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-async function writeAppTypeDeclarations({ baseDir, distDir, imageImportsEnabled, hasPagesDir, hasAppDir }) {
+async function writeAppTypeDeclarations({ baseDir, distDir, imageImportsEnabled, hasPagesDir, hasAppDir, strictRouteTypes, typedRoutes }) {
     // Reference `next` types
     const appTypeDeclarations = _path.default.join(baseDir, 'next-env.d.ts');
     // Defaults EOL to system default
@@ -39,22 +39,32 @@ async function writeAppTypeDeclarations({ baseDir, distDir, imageImportsEnabled,
    * using Typescript .
    *
    * @see https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html
-   */ const directives = [
+   */ const lines = [
         // Include the core Next.js typings.
         '/// <reference types="next" />'
     ];
     if (imageImportsEnabled) {
-        directives.push('/// <reference types="next/image-types/global" />');
+        lines.push('/// <reference types="next/image-types/global" />');
     }
     if (hasAppDir && hasPagesDir) {
-        directives.push('/// <reference types="next/navigation-types/compat/navigation" />');
+        lines.push('/// <reference types="next/navigation-types/compat/navigation" />');
     }
     const routeTypesPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/routes.d.ts');
     // Use ESM import instead of triple-slash reference for better ESLint compatibility
-    directives.push(`import "./${routeTypesPath}";`);
+    lines.push(`import "./${routeTypesPath}";`);
+    if (strictRouteTypes) {
+        const cacheLifePath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/cache-life.d.ts');
+        lines.push(`import "./${cacheLifePath}";`);
+        const routeValidatorPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/validator.ts');
+        lines.push(`import "./${routeValidatorPath}";`);
+        if (typedRoutes === true) {
+            const linkTypesPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/link.d.ts');
+            lines.push(`import "./${linkTypesPath}";`);
+        }
+    }
     // Push the notice in.
-    directives.push('', '// NOTE: This file should not be edited', `// see https://nextjs.org/docs/${hasAppDir ? 'app' : 'pages'}/api-reference/config/typescript for more information.`);
-    const content = directives.join(eol) + eol;
+    lines.push('', '// NOTE: This file should not be edited', `// see https://nextjs.org/docs/${hasAppDir ? 'app' : 'pages'}/api-reference/config/typescript for more information.`);
+    const content = lines.join(eol) + eol;
     // Avoids an un-necessary write on read-only fs
     if (currentContent === content) {
         return;