next 16.2.11 → 16.2.12

package/dist/.build-commit

@@ -1 +1 @@
-9beca0821cf4606ae33466ed6f4fc75f2887a4da
+2234717e74ff24cd179d8128fa8af6c46cc4f24e

package/dist/bin/next

@@ -84,7 +84,7 @@ const program = new NextRootCommand();
 program.name('next').description('The Next.js CLI allows you to develop, build, start your application, and more.').configureHelp({
     formatHelp: (cmd, helper)=>(0, _formatclihelpoutput.formatCliHelpOutput)(cmd, helper),
     subcommandTerm: (cmd)=>`${cmd.name()} ${cmd.usage()}`
-}).helpCommand(false).helpOption('-h, --help', 'Displays this message.').version(`Next.js v${"16.2.11"}`, '-v, --version', 'Outputs the Next.js version.');
+}).helpCommand(false).helpOption('-h, --help', 'Displays this message.').version(`Next.js v${"16.2.12"}`, '-v, --version', 'Outputs the Next.js version.');
 program.command('build').description('Creates an optimized production build of your application. The output displays information about each route.').argument('[directory]', `A directory on which to build the application. ${(0, _picocolors.italic)('If no directory is provided, the current directory will be used.')}`).option('--experimental-analyze', 'Analyze bundle output. Only compatible with Turbopack.').option('-d, --debug', 'Enables a more verbose build output.').option('--debug-prerender', 'Enables debug mode for prerendering. Not for production use!').option('--no-mangling', 'Disables mangling.').option('--profile', 'Enables production profiling for React.').option('--experimental-app-only', 'Builds only App Router routes.').option('--turbo', 'Builds using Turbopack.').option('--turbopack', 'Builds using Turbopack.').option('--webpack', 'Builds using webpack.').addOption(new _commander.Option('--experimental-build-mode [mode]', 'Uses an experimental build mode.').choices([
     'compile',
     'generate',
@@ -170,7 +170,7 @@ program.command('telemetry').description(`Allows you to enable or disable Next.j
 program.command('typegen').description('Generate TypeScript definitions for routes, pages, and layouts without running a full build.').argument('[directory]', `A directory on which to generate types. ${(0, _picocolors.italic)('If no directory is provided, the current directory will be used.')}`).action((directory, options)=>// ensure process exits after typegen completes so open handles/connections
     // don't cause process to hang
     import('../cli/next-typegen.js').then((mod)=>mod.nextTypegen(options, directory).then(()=>process.exit(0)))).usage('[directory] [options]');
-const nextVersion = "16.2.11" || 'unknown';
+const nextVersion = "16.2.12" || 'unknown';
 program.command('upgrade').description('Upgrade Next.js apps to desired versions with a single command.').argument('[directory]', `A Next.js project directory to upgrade. ${(0, _picocolors.italic)('If no directory is provided, the current directory will be used.')}`).usage('[directory] [options]').option('--revision <revision>', 'Specify the target Next.js version using an NPM dist tag (e.g. "latest", "canary", "rc", "beta") or an exact version number (e.g. "15.0.0").', nextVersion.includes('-canary.') ? 'canary' : nextVersion.includes('-rc.') ? 'rc' : nextVersion.includes('-beta.') ? 'beta' : 'latest').option('--verbose', 'Verbose output', false).action(async (directory, options)=>{
     const mod = await import('../cli/next-upgrade.js');
     mod.spawnNextUpgrade(directory, options);

package/dist/build/index.js

@@ -401,7 +401,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
     try {
         const nextBuildSpan = (0, _trace.trace)('next-build', undefined, {
             buildMode: experimentalBuildMode,
-            version: "16.2.11",
+            version: "16.2.12",
             ...enabledFeatures
         });
         _buildcontext.NextBuildContext.nextBuildSpan = nextBuildSpan;
@@ -837,7 +837,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
             // Files outside of the distDir can be "type": "module"
             await writeFileUtf8(_path.default.join(distDir, 'package.json'), '{"type": "commonjs"}');
             // These are written to distDir, so they need to come after creating and cleaning distDr.
-            await (0, _builddiagnostics.recordFrameworkVersion)("16.2.11");
+            await (0, _builddiagnostics.recordFrameworkVersion)("16.2.12");
             await (0, _builddiagnostics.updateBuildDiagnostics)({
                 buildStage: 'start'
             });
@@ -2565,7 +2565,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                         configOutDir: _path.default.join(dir, configOutDir),
                         staticPages,
                         serverPropsPages,
-                        nextVersion: "16.2.11",
+                        nextVersion: "16.2.12",
                         tracingRoot: outputFileTracingRoot,
                         hasNodeMiddleware,
                         hasInstrumentationHook,

package/dist/build/load-jsconfig.js

@@ -25,8 +25,9 @@ const _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
 const _getTypeScriptConfiguration = require("../lib/typescript/getTypeScriptConfiguration");
 const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
-const _hasnecessarydependencies = require("../lib/has-necessary-dependencies");
 const _codeframe = require("../shared/lib/errors/code-frame");
+const _runTypeScriptCli = require("../lib/typescript/runTypeScriptCli");
+const _loadTsConfig = require("../lib/typescript/loadTsConfig");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -103,19 +104,14 @@ function parseJsonFile(filePath) {
 }
 async function loadJsConfig(dir, config) {
     var _jsConfig_compilerOptions;
-    let typeScriptPath;
-    try {
-        const deps = (0, _hasnecessarydependencies.hasNecessaryDependencies)(dir, [
-            {
-                pkg: 'typescript',
-                file: 'typescript/lib/typescript.js',
-                exportsRestrict: true
-            }
-        ]);
-        typeScriptPath = deps.resolved.get('typescript');
-    } catch  {}
+    const useTypeScriptCli = Boolean(config.experimental.useTypeScriptCli);
+    const typeScriptPackage = (0, _runTypeScriptCli.getTypeScriptPackageInfo)(dir);
+    const typeScriptPath = useTypeScriptCli ? typeScriptPackage == null ? void 0 : typeScriptPackage.tscPath : typeScriptPackage == null ? void 0 : typeScriptPackage.apiPath;
     const tsConfigFileName = config.typescript.tsconfigPath || 'tsconfig.json';
     const tsConfigPath = _path.default.join(dir, tsConfigFileName);
+    if (!useTypeScriptCli && typeScriptPackage && !typeScriptPackage.apiPath && !(0, _runTypeScriptCli.hasNativeTypeScriptPreview)(dir) && _fs.default.existsSync(tsConfigPath)) {
+        throw (0, _runTypeScriptCli.getTypeScriptApiMissingError)(typeScriptPackage.version);
+    }
     const useTypeScript = Boolean(typeScriptPath && _fs.default.existsSync(tsConfigPath));
     let implicitBaseurl;
     let jsConfig;
@@ -125,11 +121,26 @@ async function loadJsConfig(dir, config) {
             TSCONFIG_WARNED = true;
             _log.info(`Using tsconfig file: ${tsConfigFileName}`);
         }
-        const ts = await Promise.resolve(require(typeScriptPath));
-        const tsConfig = await (0, _getTypeScriptConfiguration.getTypeScriptConfiguration)(ts, tsConfigPath, true);
-        jsConfig = {
-            compilerOptions: tsConfig.options
-        };
+        if (useTypeScriptCli) {
+            const tsConfig = await (0, _runTypeScriptCli.getTypeScriptConfigurationCli)({
+                baseDir: dir,
+                tsConfigPath,
+                tscPath: typeScriptPath
+            });
+            const configOrigins = (0, _loadTsConfig.loadTsConfigOptions)(tsConfigPath);
+            jsConfig = {
+                compilerOptions: {
+                    ...tsConfig.compilerOptions,
+                    pathsBasePath: configOrigins.pathsBasePath
+                }
+            };
+        } else {
+            const ts = await Promise.resolve(require(typeScriptPath));
+            const tsConfig = await (0, _getTypeScriptConfiguration.getTypeScriptConfiguration)(ts, tsConfigPath, true);
+            jsConfig = {
+                compilerOptions: tsConfig.options
+            };
+        }
         implicitBaseurl = _path.default.dirname(tsConfigPath);
     }
     const jsConfigPath = _path.default.join(dir, 'jsconfig.json');
@@ -140,13 +151,22 @@ async function loadJsConfig(dir, config) {
     let resolvedBaseUrl;
     if (jsConfig == null ? void 0 : (_jsConfig_compilerOptions = jsConfig.compilerOptions) == null ? void 0 : _jsConfig_compilerOptions.baseUrl) {
         resolvedBaseUrl = {
-            baseUrl: _path.default.resolve(dir, jsConfig.compilerOptions.baseUrl),
+            baseUrl: _path.default.resolve(implicitBaseurl ?? dir, jsConfig.compilerOptions.baseUrl),
             isImplicit: false
         };
     } else {
-        if (implicitBaseurl) {
+        var _jsConfig_compilerOptions1;
+        // TypeScript 5.0+: `pathsBasePath` is the directory of the tsconfig that
+        // defines `paths`. For paths inherited from an extended base tsconfig (e.g.
+        // a workspace-root tsconfig.base.json for nx monorepo), this is the base
+        // config's directory — not the app tsconfig dir. Using it ensures JsConfigPathsPlugin
+        // joins path-mapping values against the correct base so `baseUrl` is not required
+        // for path aliases to work in webpack.
+        const pathsBasePath = jsConfig == null ? void 0 : (_jsConfig_compilerOptions1 = jsConfig.compilerOptions) == null ? void 0 : _jsConfig_compilerOptions1.pathsBasePath;
+        const effectiveBaseUrl = pathsBasePath ?? implicitBaseurl;
+        if (effectiveBaseUrl) {
             resolvedBaseUrl = {
-                baseUrl: implicitBaseurl,
+                baseUrl: effectiveBaseUrl,
                 isImplicit: true
             };
         }

package/dist/build/load-jsconfig.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/build/load-jsconfig.ts"],"sourcesContent":["import path from 'path'\nimport fs from 'fs'\nimport type { NextConfigComplete } from '../server/config-shared'\nimport * as Log from './output/log'\nimport { getTypeScriptConfiguration } from '../lib/typescript/getTypeScriptConfiguration'\nimport { readFileSync } from 'fs'\nimport isError from '../lib/is-error'\nimport { hasNecessaryDependencies } from '../lib/has-necessary-dependencies'\nimport { codeFrameColumns } from '../shared/lib/errors/code-frame'\n\nlet TSCONFIG_WARNED = false\n\nexport function parseJsonFile(filePath: string) {\n  const JSON5 =\n    require('next/dist/compiled/json5') as typeof import('next/dist/compiled/json5')\n  const contents = readFileSync(filePath, 'utf8')\n\n  // Special case an empty file\n  if (contents.trim() === '') {\n    return {}\n  }\n\n  try {\n    return JSON5.parse(contents)\n  } catch (err) {\n    if (!isError(err)) throw err\n    const codeFrame = codeFrameColumns(\n      String(contents),\n      {\n        start: {\n          line: (err as Error & { lineNumber?: number }).lineNumber || 1,\n          column:\n            (err as Error & { columnNumber?: number }).columnNumber ||\n            undefined,\n        },\n      },\n      { message: err.message, color: true }\n    )\n    throw new Error(\n      `Failed to parse \"${filePath}\":\\n${codeFrame ?? err.message}`\n    )\n  }\n}\n\nexport type ResolvedBaseUrl =\n  | { baseUrl: string; isImplicit: boolean }\n  | undefined\n\nexport type JsConfig = { compilerOptions: Record<string, any> } | undefined\n\nexport default async function loadJsConfig(\n  dir: string,\n  config: NextConfigComplete\n): Promise<{\n  useTypeScript: boolean\n  jsConfig: JsConfig\n  jsConfigPath?: string\n  resolvedBaseUrl: ResolvedBaseUrl\n}> {\n  let typeScriptPath: string | undefined\n  try {\n    const deps = hasNecessaryDependencies(dir, [\n      {\n        pkg: 'typescript',\n        file: 'typescript/lib/typescript.js',\n        exportsRestrict: true,\n      },\n    ])\n    typeScriptPath = deps.resolved.get('typescript')\n  } catch {}\n  const tsConfigFileName = config.typescript.tsconfigPath || 'tsconfig.json'\n  const tsConfigPath = path.join(dir, tsConfigFileName)\n  const useTypeScript = Boolean(typeScriptPath && fs.existsSync(tsConfigPath))\n\n  let implicitBaseurl\n  let jsConfig: { compilerOptions: Record<string, any> } | undefined\n  // jsconfig is a subset of tsconfig\n  if (useTypeScript) {\n    if (tsConfigFileName !== 'tsconfig.json' && TSCONFIG_WARNED === false) {\n      TSCONFIG_WARNED = true\n      Log.info(`Using tsconfig file: ${tsConfigFileName}`)\n    }\n\n    const ts = (await Promise.resolve(\n      require(typeScriptPath!)\n    )) as typeof import('typescript')\n    const tsConfig = await getTypeScriptConfiguration(ts, tsConfigPath, true)\n    jsConfig = { compilerOptions: tsConfig.options }\n    implicitBaseurl = path.dirname(tsConfigPath)\n  }\n\n  const jsConfigPath = path.join(dir, 'jsconfig.json')\n  if (!useTypeScript && fs.existsSync(jsConfigPath)) {\n    jsConfig = parseJsonFile(jsConfigPath)\n    implicitBaseurl = path.dirname(jsConfigPath)\n  }\n\n  let resolvedBaseUrl: ResolvedBaseUrl\n  if (jsConfig?.compilerOptions?.baseUrl) {\n    resolvedBaseUrl = {\n      baseUrl: path.resolve(dir, jsConfig.compilerOptions.baseUrl),\n      isImplicit: false,\n    }\n  } else {\n    if (implicitBaseurl) {\n      resolvedBaseUrl = {\n        baseUrl: implicitBaseurl,\n        isImplicit: true,\n      }\n    }\n  }\n\n  return {\n    useTypeScript,\n    jsConfig,\n    resolvedBaseUrl,\n    jsConfigPath: useTypeScript\n      ? tsConfigPath\n      : fs.existsSync(jsConfigPath)\n        ? jsConfigPath\n        : undefined,\n  }\n}\n"],"names":["loadJsConfig","parseJsonFile","TSCONFIG_WARNED","filePath","JSON5","require","contents","readFileSync","trim","parse","err","isError","codeFrame","codeFrameColumns","String","start","line","lineNumber","column","columnNumber","undefined","message","color","Error","dir","config","jsConfig","typeScriptPath","deps","hasNecessaryDependencies","pkg","file","exportsRestrict","resolved","get","tsConfigFileName","typescript","tsconfigPath","tsConfigPath","path","join","useTypeScript","Boolean","fs","existsSync","implicitBaseurl","Log","info","ts","Promise","resolve","tsConfig","getTypeScriptConfiguration","compilerOptions","options","dirname","jsConfigPath","resolvedBaseUrl","baseUrl","isImplicit"],"mappings":";;;;;;;;;;;;;;;IAkDA,OAwEC;eAxE6BA;;IAtCdC,aAAa;eAAbA;;;6DAZC;4DACF;6DAEM;4CACsB;gEAEvB;0CACqB;2BACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjC,IAAIC,kBAAkB;AAEf,SAASD,cAAcE,QAAgB;IAC5C,MAAMC,QACJC,QAAQ;IACV,MAAMC,WAAWC,IAAAA,gBAAY,EAACJ,UAAU;IAExC,6BAA6B;IAC7B,IAAIG,SAASE,IAAI,OAAO,IAAI;QAC1B,OAAO,CAAC;IACV;IAEA,IAAI;QACF,OAAOJ,MAAMK,KAAK,CAACH;IACrB,EAAE,OAAOI,KAAK;QACZ,IAAI,CAACC,IAAAA,gBAAO,EAACD,MAAM,MAAMA;QACzB,MAAME,YAAYC,IAAAA,2BAAgB,EAChCC,OAAOR,WACP;YACES,OAAO;gBACLC,MAAM,AAACN,IAAwCO,UAAU,IAAI;gBAC7DC,QACE,AAACR,IAA0CS,YAAY,IACvDC;YACJ;QACF,GACA;YAAEC,SAASX,IAAIW,OAAO;YAAEC,OAAO;QAAK;QAEtC,MAAM,qBAEL,CAFK,IAAIC,MACR,CAAC,iBAAiB,EAAEpB,SAAS,IAAI,EAAES,aAAaF,IAAIW,OAAO,EAAE,GADzD,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;AACF;AAQe,eAAerB,aAC5BwB,GAAW,EACXC,MAA0B;QA8CtBC;IAvCJ,IAAIC;IACJ,IAAI;QACF,MAAMC,OAAOC,IAAAA,kDAAwB,EAACL,KAAK;YACzC;gBACEM,KAAK;gBACLC,MAAM;gBACNC,iBAAiB;YACnB;SACD;QACDL,iBAAiBC,KAAKK,QAAQ,CAACC,GAAG,CAAC;IACrC,EAAE,OAAM,CAAC;IACT,MAAMC,mBAAmBV,OAAOW,UAAU,CAACC,YAAY,IAAI;IAC3D,MAAMC,eAAeC,aAAI,CAACC,IAAI,CAAChB,KAAKW;IACpC,MAAMM,gBAAgBC,QAAQf,kBAAkBgB,WAAE,CAACC,UAAU,CAACN;IAE9D,IAAIO;IACJ,IAAInB;IACJ,mCAAmC;IACnC,IAAIe,eAAe;QACjB,IAAIN,qBAAqB,mBAAmBjC,oBAAoB,OAAO;YACrEA,kBAAkB;YAClB4C,KAAIC,IAAI,CAAC,CAAC,qBAAqB,EAAEZ,kBAAkB;QACrD;QAEA,MAAMa,KAAM,MAAMC,QAAQC,OAAO,CAC/B7C,QAAQsB;QAEV,MAAMwB,WAAW,MAAMC,IAAAA,sDAA0B,EAACJ,IAAIV,cAAc;QACpEZ,WAAW;YAAE2B,iBAAiBF,SAASG,OAAO;QAAC;QAC/CT,kBAAkBN,aAAI,CAACgB,OAAO,CAACjB;IACjC;IAEA,MAAMkB,eAAejB,aAAI,CAACC,IAAI,CAAChB,KAAK;IACpC,IAAI,CAACiB,iBAAiBE,WAAE,CAACC,UAAU,CAACY,eAAe;QACjD9B,WAAWzB,cAAcuD;QACzBX,kBAAkBN,aAAI,CAACgB,OAAO,CAACC;IACjC;IAEA,IAAIC;IACJ,IAAI/B,6BAAAA,4BAAAA,SAAU2B,eAAe,qBAAzB3B,0BAA2BgC,OAAO,EAAE;QACtCD,kBAAkB;YAChBC,SAASnB,aAAI,CAACW,OAAO,CAAC1B,KAAKE,SAAS2B,eAAe,CAACK,OAAO;YAC3DC,YAAY;QACd;IACF,OAAO;QACL,IAAId,iBAAiB;YACnBY,kBAAkB;gBAChBC,SAASb;gBACTc,YAAY;YACd;QACF;IACF;IAEA,OAAO;QACLlB;QACAf;QACA+B;QACAD,cAAcf,gBACVH,eACAK,WAAE,CAACC,UAAU,CAACY,gBACZA,eACApC;IACR;AACF","ignoreList":[0]}
+{"version":3,"sources":["../../src/build/load-jsconfig.ts"],"sourcesContent":["import path from 'path'\nimport fs from 'fs'\nimport type { NextConfigComplete } from '../server/config-shared'\nimport * as Log from './output/log'\nimport { getTypeScriptConfiguration } from '../lib/typescript/getTypeScriptConfiguration'\nimport { readFileSync } from 'fs'\nimport isError from '../lib/is-error'\nimport { codeFrameColumns } from '../shared/lib/errors/code-frame'\nimport {\n  getTypeScriptApiMissingError,\n  getTypeScriptConfigurationCli,\n  getTypeScriptPackageInfo,\n  hasNativeTypeScriptPreview,\n} from '../lib/typescript/runTypeScriptCli'\nimport { loadTsConfigOptions } from '../lib/typescript/loadTsConfig'\n\nlet TSCONFIG_WARNED = false\n\nexport function parseJsonFile(filePath: string) {\n  const JSON5 =\n    require('next/dist/compiled/json5') as typeof import('next/dist/compiled/json5')\n  const contents = readFileSync(filePath, 'utf8')\n\n  // Special case an empty file\n  if (contents.trim() === '') {\n    return {}\n  }\n\n  try {\n    return JSON5.parse(contents)\n  } catch (err) {\n    if (!isError(err)) throw err\n    const codeFrame = codeFrameColumns(\n      String(contents),\n      {\n        start: {\n          line: (err as Error & { lineNumber?: number }).lineNumber || 1,\n          column:\n            (err as Error & { columnNumber?: number }).columnNumber ||\n            undefined,\n        },\n      },\n      { message: err.message, color: true }\n    )\n    throw new Error(\n      `Failed to parse \"${filePath}\":\\n${codeFrame ?? err.message}`\n    )\n  }\n}\n\nexport type ResolvedBaseUrl =\n  | { baseUrl: string; isImplicit: boolean }\n  | undefined\n\nexport type JsConfig = { compilerOptions: Record<string, any> } | undefined\n\nexport default async function loadJsConfig(\n  dir: string,\n  config: NextConfigComplete\n): Promise<{\n  useTypeScript: boolean\n  jsConfig: JsConfig\n  jsConfigPath?: string\n  resolvedBaseUrl: ResolvedBaseUrl\n}> {\n  const useTypeScriptCli = Boolean(config.experimental.useTypeScriptCli)\n  const typeScriptPackage = getTypeScriptPackageInfo(dir)\n  const typeScriptPath = useTypeScriptCli\n    ? typeScriptPackage?.tscPath\n    : typeScriptPackage?.apiPath\n  const tsConfigFileName = config.typescript.tsconfigPath || 'tsconfig.json'\n  const tsConfigPath = path.join(dir, tsConfigFileName)\n\n  if (\n    !useTypeScriptCli &&\n    typeScriptPackage &&\n    !typeScriptPackage.apiPath &&\n    !hasNativeTypeScriptPreview(dir) &&\n    fs.existsSync(tsConfigPath)\n  ) {\n    throw getTypeScriptApiMissingError(typeScriptPackage.version)\n  }\n\n  const useTypeScript = Boolean(typeScriptPath && fs.existsSync(tsConfigPath))\n\n  let implicitBaseurl\n  let jsConfig: { compilerOptions: Record<string, any> } | undefined\n  // jsconfig is a subset of tsconfig\n  if (useTypeScript) {\n    if (tsConfigFileName !== 'tsconfig.json' && TSCONFIG_WARNED === false) {\n      TSCONFIG_WARNED = true\n      Log.info(`Using tsconfig file: ${tsConfigFileName}`)\n    }\n\n    if (useTypeScriptCli) {\n      const tsConfig = await getTypeScriptConfigurationCli({\n        baseDir: dir,\n        tsConfigPath,\n        tscPath: typeScriptPath!,\n      })\n      const configOrigins = loadTsConfigOptions(tsConfigPath)\n      jsConfig = {\n        compilerOptions: {\n          ...tsConfig.compilerOptions,\n          pathsBasePath: configOrigins.pathsBasePath,\n        },\n      }\n    } else {\n      const ts = (await Promise.resolve(\n        require(typeScriptPath!)\n      )) as typeof import('typescript')\n      const tsConfig = await getTypeScriptConfiguration(ts, tsConfigPath, true)\n      jsConfig = { compilerOptions: tsConfig.options }\n    }\n    implicitBaseurl = path.dirname(tsConfigPath)\n  }\n\n  const jsConfigPath = path.join(dir, 'jsconfig.json')\n  if (!useTypeScript && fs.existsSync(jsConfigPath)) {\n    jsConfig = parseJsonFile(jsConfigPath)\n    implicitBaseurl = path.dirname(jsConfigPath)\n  }\n\n  let resolvedBaseUrl: ResolvedBaseUrl\n  if (jsConfig?.compilerOptions?.baseUrl) {\n    resolvedBaseUrl = {\n      baseUrl: path.resolve(\n        implicitBaseurl ?? dir,\n        jsConfig.compilerOptions.baseUrl\n      ),\n      isImplicit: false,\n    }\n  } else {\n    // TypeScript 5.0+: `pathsBasePath` is the directory of the tsconfig that\n    // defines `paths`. For paths inherited from an extended base tsconfig (e.g.\n    // a workspace-root tsconfig.base.json for nx monorepo), this is the base\n    // config's directory — not the app tsconfig dir. Using it ensures JsConfigPathsPlugin\n    // joins path-mapping values against the correct base so `baseUrl` is not required\n    // for path aliases to work in webpack.\n    const pathsBasePath: string | undefined =\n      jsConfig?.compilerOptions?.pathsBasePath\n    const effectiveBaseUrl = pathsBasePath ?? implicitBaseurl\n    if (effectiveBaseUrl) {\n      resolvedBaseUrl = {\n        baseUrl: effectiveBaseUrl,\n        isImplicit: true,\n      }\n    }\n  }\n\n  return {\n    useTypeScript,\n    jsConfig,\n    resolvedBaseUrl,\n    jsConfigPath: useTypeScript\n      ? tsConfigPath\n      : fs.existsSync(jsConfigPath)\n        ? jsConfigPath\n        : undefined,\n  }\n}\n"],"names":["loadJsConfig","parseJsonFile","TSCONFIG_WARNED","filePath","JSON5","require","contents","readFileSync","trim","parse","err","isError","codeFrame","codeFrameColumns","String","start","line","lineNumber","column","columnNumber","undefined","message","color","Error","dir","config","jsConfig","useTypeScriptCli","Boolean","experimental","typeScriptPackage","getTypeScriptPackageInfo","typeScriptPath","tscPath","apiPath","tsConfigFileName","typescript","tsconfigPath","tsConfigPath","path","join","hasNativeTypeScriptPreview","fs","existsSync","getTypeScriptApiMissingError","version","useTypeScript","implicitBaseurl","Log","info","tsConfig","getTypeScriptConfigurationCli","baseDir","configOrigins","loadTsConfigOptions","compilerOptions","pathsBasePath","ts","Promise","resolve","getTypeScriptConfiguration","options","dirname","jsConfigPath","resolvedBaseUrl","baseUrl","isImplicit","effectiveBaseUrl"],"mappings":"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","ignoreList":[0]}

package/dist/build/next-config-ts/transpile-config.js

@@ -11,56 +11,15 @@ Object.defineProperty(exports, "transpileConfig", {
 const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _nodefs = require("node:fs");
 const _nodeurl = require("node:url");
-const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("next/dist/compiled/comment-json"));
 const _requirehook = require("./require-hook");
 const _log = require("../output/log");
 const _utils = require("../../server/lib/utils");
+const _loadTsConfig = require("../../lib/typescript/loadTsConfig");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
 function resolveSWCOptions(cwd, compilerOptions) {
     var _process_versions, _process;
     return {
@@ -74,7 +33,7 @@ function resolveSWCOptions(cwd, compilerOptions) {
             ...compilerOptions.baseUrl ? {
                 baseUrl: _nodepath.default.resolve(cwd, compilerOptions.baseUrl)
             } : compilerOptions.paths ? {
-                baseUrl: cwd
+                baseUrl: compilerOptions.pathsBasePath ?? cwd
             } : {}
         },
         module: {
@@ -89,76 +48,6 @@ function resolveSWCOptions(cwd, compilerOptions) {
         }
     };
 }
-function resolveExtends(extendsPath, currentConfigDir) {
-    // Relative paths are resolved relative to the current config's directory
-    if (extendsPath.startsWith('./') || extendsPath.startsWith('../') || _nodepath.default.isAbsolute(extendsPath)) {
-        const resolved = _nodepath.default.resolve(currentConfigDir, extendsPath);
-        // TypeScript allows omitting .json extension
-        if ((0, _nodefs.existsSync)(resolved)) {
-            return resolved;
-        }
-        if (!resolved.endsWith('.json') && (0, _nodefs.existsSync)(resolved + '.json')) {
-            return resolved + '.json';
-        }
-        return resolved;
-    }
-    // Package paths - use require.resolve to find the package
-    try {
-        // Try resolving as a direct path within the package
-        return require.resolve(extendsPath, {
-            paths: [
-                currentConfigDir
-            ]
-        });
-    } catch  {
-        // If that fails, try appending tsconfig.json for package names like "@tsconfig/node18"
-        try {
-            return require.resolve(extendsPath + '/tsconfig.json', {
-                paths: [
-                    currentConfigDir
-                ]
-            });
-        } catch  {
-            // Return the original path and let it fail later with a clear error
-            return _nodepath.default.resolve(currentConfigDir, extendsPath);
-        }
-    }
-}
-function loadTsConfigFile(configPath, visited) {
-    const resolvedPath = _nodepath.default.resolve(configPath);
-    if (visited.has(resolvedPath)) {
-        return {};
-    }
-    visited.add(resolvedPath);
-    if (!(0, _nodefs.existsSync)(resolvedPath)) {
-        return {};
-    }
-    const configContent = (0, _nodefs.readFileSync)(resolvedPath, 'utf8');
-    const config = _commentjson.parse(configContent);
-    const configDir = _nodepath.default.dirname(resolvedPath);
-    let mergedOptions = {};
-    // Note that config options from `extends` should get overwritten, not merged
-    if (config.extends) {
-        const extendsList = Array.isArray(config.extends) ? config.extends : [
-            config.extends
-        ];
-        for (const extendsPath of extendsList){
-            const parentConfigPath = resolveExtends(extendsPath, configDir);
-            const parentOptions = loadTsConfigFile(parentConfigPath, visited);
-            mergedOptions = {
-                ...mergedOptions,
-                ...parentOptions
-            };
-        }
-    }
-    const currentOptions = config.compilerOptions ?? {};
-    mergedOptions = {
-        ...mergedOptions,
-        paths: currentOptions.paths ?? mergedOptions.paths,
-        baseUrl: currentOptions.baseUrl ?? mergedOptions.baseUrl
-    };
-    return mergedOptions;
-}
 async function loadTsConfig(dir) {
     // NOTE: This doesn't fully cover the edge case for setting
     // "typescript.tsconfigPath" in next config which is currently
@@ -169,7 +58,7 @@ async function loadTsConfig(dir) {
     if (!(0, _nodefs.existsSync)(resolvedTsConfigPath)) {
         return {};
     }
-    return loadTsConfigFile(resolvedTsConfigPath, new Set());
+    return (0, _loadTsConfig.loadTsConfigOptions)(resolvedTsConfigPath);
 }
 async function transpileConfig({ nextConfigPath, dir }) {
     try {

package/dist/build/next-config-ts/transpile-config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/build/next-config-ts/transpile-config.ts"],"sourcesContent":["import type { Options as SWCOptions } from '@swc/core'\nimport type { CompilerOptions } from 'typescript'\n\nimport path from 'node:path'\nimport { readFileSync, existsSync } from 'node:fs'\nimport { pathToFileURL } from 'node:url'\nimport * as CommentJson from 'next/dist/compiled/comment-json'\nimport { deregisterHook, registerHook, requireFromString } from './require-hook'\nimport { warn, warnOnce } from '../output/log'\nimport { getNodeOptionsArgs } from '../../server/lib/utils'\n\ntype RelevantCompilerOptions = Pick<CompilerOptions, 'paths' | 'baseUrl'>\n\nfunction resolveSWCOptions(\n  cwd: string,\n  compilerOptions: RelevantCompilerOptions\n): SWCOptions {\n  return {\n    jsc: {\n      parser: {\n        syntax: 'typescript',\n      },\n      ...(compilerOptions.paths ? { paths: compilerOptions.paths } : {}),\n      ...(compilerOptions.baseUrl\n        ? // Needs to be an absolute path.\n          { baseUrl: path.resolve(cwd, compilerOptions.baseUrl) }\n        : compilerOptions.paths\n          ? // If paths is given, baseUrl is required.\n            { baseUrl: cwd }\n          : {}),\n    },\n    module: {\n      type: 'commonjs',\n    },\n    isModule: 'unknown',\n    env: {\n      targets: {\n        // Setting the Node.js version can reduce unnecessary code generation.\n        node: process?.versions?.node ?? '20.19.0',\n      },\n    },\n  } satisfies SWCOptions\n}\n\nfunction resolveExtends(extendsPath: string, currentConfigDir: string): string {\n  // Relative paths are resolved relative to the current config's directory\n  if (\n    extendsPath.startsWith('./') ||\n    extendsPath.startsWith('../') ||\n    path.isAbsolute(extendsPath)\n  ) {\n    const resolved = path.resolve(currentConfigDir, extendsPath)\n    // TypeScript allows omitting .json extension\n    if (existsSync(resolved)) {\n      return resolved\n    }\n    if (!resolved.endsWith('.json') && existsSync(resolved + '.json')) {\n      return resolved + '.json'\n    }\n    return resolved\n  }\n\n  // Package paths - use require.resolve to find the package\n  try {\n    // Try resolving as a direct path within the package\n    return require.resolve(extendsPath, { paths: [currentConfigDir] })\n  } catch {\n    // If that fails, try appending tsconfig.json for package names like \"@tsconfig/node18\"\n    try {\n      return require.resolve(extendsPath + '/tsconfig.json', {\n        paths: [currentConfigDir],\n      })\n    } catch {\n      // Return the original path and let it fail later with a clear error\n      return path.resolve(currentConfigDir, extendsPath)\n    }\n  }\n}\n\nfunction loadTsConfigFile(\n  configPath: string,\n  visited: Set<string>\n): RelevantCompilerOptions {\n  const resolvedPath = path.resolve(configPath)\n\n  if (visited.has(resolvedPath)) {\n    return {}\n  }\n  visited.add(resolvedPath)\n\n  if (!existsSync(resolvedPath)) {\n    return {}\n  }\n\n  const configContent = readFileSync(resolvedPath, 'utf8')\n  const config = CommentJson.parse(configContent)\n  const configDir = path.dirname(resolvedPath)\n\n  let mergedOptions: RelevantCompilerOptions = {}\n\n  // Note that config options from `extends` should get overwritten, not merged\n  if (config.extends) {\n    const extendsList = Array.isArray(config.extends)\n      ? config.extends\n      : [config.extends]\n\n    for (const extendsPath of extendsList) {\n      const parentConfigPath = resolveExtends(extendsPath, configDir)\n      const parentOptions = loadTsConfigFile(parentConfigPath, visited)\n      mergedOptions = { ...mergedOptions, ...parentOptions }\n    }\n  }\n\n  const currentOptions = config.compilerOptions ?? {}\n  mergedOptions = {\n    ...mergedOptions,\n    paths: currentOptions.paths ?? mergedOptions.paths,\n    baseUrl: currentOptions.baseUrl ?? mergedOptions.baseUrl,\n  }\n\n  return mergedOptions\n}\n\nasync function loadTsConfig(dir: string): Promise<RelevantCompilerOptions> {\n  // NOTE: This doesn't fully cover the edge case for setting\n  // \"typescript.tsconfigPath\" in next config which is currently\n  // a restriction.\n  // It's a chicken-and-egg problem since we need to transpile\n  // the next config to get that value.\n  const resolvedTsConfigPath = path.join(dir, 'tsconfig.json')\n\n  if (!existsSync(resolvedTsConfigPath)) {\n    return {}\n  }\n\n  return loadTsConfigFile(resolvedTsConfigPath, new Set())\n}\n\nexport async function transpileConfig({\n  nextConfigPath,\n  dir,\n}: {\n  nextConfigPath: string\n  dir: string\n}) {\n  try {\n    // envs are passed to the workers and preserve the flag\n    if (process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED === 'true') {\n      try {\n        // Node.js v22.10.0+\n        // Value is 'strip' or 'transform' based on how the feature is enabled.\n        // https://nodejs.org/api/process.html#processfeaturestypescript\n        // TODO: Remove `as any` once we bump @types/node to v22.10.0+\n        if ((process.features as any).typescript) {\n          // Run import() here to catch errors and fallback to legacy resolution.\n          return (await import(pathToFileURL(nextConfigPath).href)).default\n        }\n\n        if (\n          getNodeOptionsArgs().includes('--no-experimental-strip-types') ||\n          process.execArgv.includes('--no-experimental-strip-types')\n        ) {\n          warnOnce(\n            `Skipped resolving \"${path.basename(nextConfigPath)}\" using Node.js native TypeScript resolution because it was disabled by the \"--no-experimental-strip-types\" flag.` +\n              ' Falling back to legacy resolution.' +\n              ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts'\n          )\n        }\n\n        // Feature is not enabled, fallback to legacy resolution for current session.\n        process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED = 'false'\n      } catch (cause) {\n        warnOnce(\n          `Failed to import \"${path.basename(nextConfigPath)}\" using Node.js native TypeScript resolution.` +\n            ' Falling back to legacy resolution.' +\n            ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts',\n          { cause }\n        )\n        // Once failed, fallback to legacy resolution for current session.\n        process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED = 'false'\n      }\n    }\n\n    const compilerOptions = await loadTsConfig(dir)\n    return handleCJS({ dir, nextConfigPath, compilerOptions })\n  } catch (cause) {\n    throw new Error(`Failed to transpile \"${path.basename(nextConfigPath)}\".`, {\n      cause,\n    })\n  }\n}\n\nasync function handleCJS({\n  dir,\n  nextConfigPath,\n  compilerOptions,\n}: {\n  dir: string\n  nextConfigPath: string\n  compilerOptions: RelevantCompilerOptions\n}) {\n  const swcOptions = resolveSWCOptions(dir, compilerOptions)\n  let hasRequire = false\n  try {\n    const nextConfigString = readFileSync(nextConfigPath, 'utf8')\n    // lazy require swc since it loads React before even setting NODE_ENV\n    // resulting loading Development React on Production\n    const { loadBindings } = require('../swc') as typeof import('../swc')\n    const bindings = await loadBindings()\n    const { code } = await bindings.transform(nextConfigString, swcOptions)\n\n    // register require hook only if require exists\n    if (code.includes('require(')) {\n      registerHook(swcOptions)\n      hasRequire = true\n    }\n\n    // filename & extension don't matter here\n    const config = requireFromString(\n      code,\n      path.resolve(dir, 'next.config.compiled.js')\n    )\n    // At this point we have already loaded the bindings without this configuration setting due to the `transform` call above.\n    // Possibly we fell back to wasm in which case, it all works out but if not we need to warn\n    // that the configuration was ignored.\n    if (config?.experimental?.useWasmBinary && !bindings.isWasm) {\n      warn(\n        'Using a next.config.ts file is incompatible with `experimental.useWasmBinary` unless ' +\n          '`--experimental-next-config-strip-types` is also passed.\\nSetting `useWasmBinary` to `false'\n      )\n      config.experimental.useWasmBinary = false\n    }\n    return config\n  } catch (error) {\n    throw error\n  } finally {\n    if (hasRequire) {\n      deregisterHook()\n    }\n  }\n}\n"],"names":["transpileConfig","resolveSWCOptions","cwd","compilerOptions","process","jsc","parser","syntax","paths","baseUrl","path","resolve","module","type","isModule","env","targets","node","versions","resolveExtends","extendsPath","currentConfigDir","startsWith","isAbsolute","resolved","existsSync","endsWith","require","loadTsConfigFile","configPath","visited","resolvedPath","has","add","configContent","readFileSync","config","CommentJson","parse","configDir","dirname","mergedOptions","extends","extendsList","Array","isArray","parentConfigPath","parentOptions","currentOptions","loadTsConfig","dir","resolvedTsConfigPath","join","Set","nextConfigPath","__NEXT_NODE_NATIVE_TS_LOADER_ENABLED","features","typescript","pathToFileURL","href","default","getNodeOptionsArgs","includes","execArgv","warnOnce","basename","cause","handleCJS","Error","swcOptions","hasRequire","nextConfigString","loadBindings","bindings","code","transform","registerHook","requireFromString","experimental","useWasmBinary","isWasm","warn","error","deregisterHook"],"mappings":"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","ignoreList":[0]}
+{"version":3,"sources":["../../../src/build/next-config-ts/transpile-config.ts"],"sourcesContent":["import type { Options as SWCOptions } from '@swc/core'\n\nimport path from 'node:path'\nimport { readFileSync, existsSync } from 'node:fs'\nimport { pathToFileURL } from 'node:url'\nimport { deregisterHook, registerHook, requireFromString } from './require-hook'\nimport { warn, warnOnce } from '../output/log'\nimport { getNodeOptionsArgs } from '../../server/lib/utils'\nimport {\n  loadTsConfigOptions,\n  type RelevantCompilerOptions,\n} from '../../lib/typescript/loadTsConfig'\n\nfunction resolveSWCOptions(\n  cwd: string,\n  compilerOptions: RelevantCompilerOptions\n): SWCOptions {\n  return {\n    jsc: {\n      parser: {\n        syntax: 'typescript',\n      },\n      ...(compilerOptions.paths ? { paths: compilerOptions.paths } : {}),\n      ...(compilerOptions.baseUrl\n        ? // Needs to be an absolute path.\n          { baseUrl: path.resolve(cwd, compilerOptions.baseUrl) }\n        : compilerOptions.paths\n          ? // If paths is given, baseUrl is required.\n            { baseUrl: compilerOptions.pathsBasePath ?? cwd }\n          : {}),\n    },\n    module: {\n      type: 'commonjs',\n    },\n    isModule: 'unknown',\n    env: {\n      targets: {\n        // Setting the Node.js version can reduce unnecessary code generation.\n        node: process?.versions?.node ?? '20.19.0',\n      },\n    },\n  } satisfies SWCOptions\n}\n\nasync function loadTsConfig(dir: string): Promise<RelevantCompilerOptions> {\n  // NOTE: This doesn't fully cover the edge case for setting\n  // \"typescript.tsconfigPath\" in next config which is currently\n  // a restriction.\n  // It's a chicken-and-egg problem since we need to transpile\n  // the next config to get that value.\n  const resolvedTsConfigPath = path.join(dir, 'tsconfig.json')\n\n  if (!existsSync(resolvedTsConfigPath)) {\n    return {}\n  }\n\n  return loadTsConfigOptions(resolvedTsConfigPath)\n}\n\nexport async function transpileConfig({\n  nextConfigPath,\n  dir,\n}: {\n  nextConfigPath: string\n  dir: string\n}) {\n  try {\n    // envs are passed to the workers and preserve the flag\n    if (process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED === 'true') {\n      try {\n        // Node.js v22.10.0+\n        // Value is 'strip' or 'transform' based on how the feature is enabled.\n        // https://nodejs.org/api/process.html#processfeaturestypescript\n        // TODO: Remove `as any` once we bump @types/node to v22.10.0+\n        if ((process.features as any).typescript) {\n          // Run import() here to catch errors and fallback to legacy resolution.\n          return (await import(pathToFileURL(nextConfigPath).href)).default\n        }\n\n        if (\n          getNodeOptionsArgs().includes('--no-experimental-strip-types') ||\n          process.execArgv.includes('--no-experimental-strip-types')\n        ) {\n          warnOnce(\n            `Skipped resolving \"${path.basename(nextConfigPath)}\" using Node.js native TypeScript resolution because it was disabled by the \"--no-experimental-strip-types\" flag.` +\n              ' Falling back to legacy resolution.' +\n              ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts'\n          )\n        }\n\n        // Feature is not enabled, fallback to legacy resolution for current session.\n        process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED = 'false'\n      } catch (cause) {\n        warnOnce(\n          `Failed to import \"${path.basename(nextConfigPath)}\" using Node.js native TypeScript resolution.` +\n            ' Falling back to legacy resolution.' +\n            ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts',\n          { cause }\n        )\n        // Once failed, fallback to legacy resolution for current session.\n        process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED = 'false'\n      }\n    }\n\n    const compilerOptions = await loadTsConfig(dir)\n    return handleCJS({ dir, nextConfigPath, compilerOptions })\n  } catch (cause) {\n    throw new Error(`Failed to transpile \"${path.basename(nextConfigPath)}\".`, {\n      cause,\n    })\n  }\n}\n\nasync function handleCJS({\n  dir,\n  nextConfigPath,\n  compilerOptions,\n}: {\n  dir: string\n  nextConfigPath: string\n  compilerOptions: RelevantCompilerOptions\n}) {\n  const swcOptions = resolveSWCOptions(dir, compilerOptions)\n  let hasRequire = false\n  try {\n    const nextConfigString = readFileSync(nextConfigPath, 'utf8')\n    // lazy require swc since it loads React before even setting NODE_ENV\n    // resulting loading Development React on Production\n    const { loadBindings } = require('../swc') as typeof import('../swc')\n    const bindings = await loadBindings()\n    const { code } = await bindings.transform(nextConfigString, swcOptions)\n\n    // register require hook only if require exists\n    if (code.includes('require(')) {\n      registerHook(swcOptions)\n      hasRequire = true\n    }\n\n    // filename & extension don't matter here\n    const config = requireFromString(\n      code,\n      path.resolve(dir, 'next.config.compiled.js')\n    )\n    // At this point we have already loaded the bindings without this configuration setting due to the `transform` call above.\n    // Possibly we fell back to wasm in which case, it all works out but if not we need to warn\n    // that the configuration was ignored.\n    if (config?.experimental?.useWasmBinary && !bindings.isWasm) {\n      warn(\n        'Using a next.config.ts file is incompatible with `experimental.useWasmBinary` unless ' +\n          '`--experimental-next-config-strip-types` is also passed.\\nSetting `useWasmBinary` to `false'\n      )\n      config.experimental.useWasmBinary = false\n    }\n    return config\n  } catch (error) {\n    throw error\n  } finally {\n    if (hasRequire) {\n      deregisterHook()\n    }\n  }\n}\n"],"names":["transpileConfig","resolveSWCOptions","cwd","compilerOptions","process","jsc","parser","syntax","paths","baseUrl","path","resolve","pathsBasePath","module","type","isModule","env","targets","node","versions","loadTsConfig","dir","resolvedTsConfigPath","join","existsSync","loadTsConfigOptions","nextConfigPath","__NEXT_NODE_NATIVE_TS_LOADER_ENABLED","features","typescript","pathToFileURL","href","default","getNodeOptionsArgs","includes","execArgv","warnOnce","basename","cause","handleCJS","Error","swcOptions","hasRequire","config","nextConfigString","readFileSync","loadBindings","require","bindings","code","transform","registerHook","requireFromString","experimental","useWasmBinary","isWasm","warn","error","deregisterHook"],"mappings":"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","ignoreList":[0]}

package/dist/build/swc/index.js

@@ -134,7 +134,7 @@ var HmrTarget = /*#__PURE__*/ function(HmrTarget) {
     HmrTarget["Server"] = "server";
     return HmrTarget;
 }({});
-const nextVersion = "16.2.11";
+const nextVersion = "16.2.12";
 const ArchName = (0, _os.arch)();
 const PlatformName = (0, _os.platform)();
 function infoLog(...args) {

package/dist/build/turbopack-analyze/index.js

@@ -93,7 +93,7 @@ async function turbopackAnalyze(analyzeContext) {
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: persistentCaching,
-        nextVersion: "16.2.11"
+        nextVersion: "16.2.12"
     }, {
         memoryLimit: (_config_experimental2 = config.experimental) == null ? void 0 : _config_experimental2.turbopackMemoryLimit,
         dependencyTracking: persistentCaching,

package/dist/build/turbopack-build/impl.js

@@ -114,7 +114,7 @@ async function turbopackBuild() {
         currentNodeJsVersion,
         isPersistentCachingEnabled: persistentCaching,
         deferredEntries: config.experimental.deferredEntries,
-        nextVersion: "16.2.11"
+        nextVersion: "16.2.12"
     };
     const sharedTurboOptions = {
         memoryLimit: (_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.turbopackMemoryLimit,

package/dist/build/type-check.js

@@ -61,19 +61,19 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 /**
- * typescript will be loaded in "next/lib/verify-typescript-setup" and
- * then passed to "next/lib/typescript/runTypeCheck" as a parameter.
+ * TypeScript setup and type checking run in a worker so the compiler's memory
+ * can be released before the rest of the build continues.
  *
  * Since it is impossible to pass a function from main thread to a worker,
  * instead of running "next/lib/typescript/runTypeCheck" in a worker,
  * we will run entire "next/lib/verify-typescript-setup" in a worker instead.
- */ function verifyAndRunTypeScript(dir, distDir, strictRouteTypes, shouldRunTypeCheck, tsconfigPath, typedRoutes, disableStaticImages, cacheDir, enableWorkerThreads, hasAppDir, hasPagesDir, appDir, pagesDir, debugBuildPaths) {
+ */ function verifyAndRunTypeScript(dir, distDir, strictRouteTypes, shouldRunTypeCheck, tsconfigPath, typedRoutes, disableStaticImages, cacheDir, enableWorkerThreads, hasAppDir, hasPagesDir, appDir, pagesDir, debugBuildPaths, useTypeScriptCli, onFirstCliOutput) {
     let impl;
     let typeCheckWorker;
-    if (shouldRunTypeCheck) {
+    if (shouldRunTypeCheck && !useTypeScriptCli) {
         typeCheckWorker = new _worker.Worker(require.resolve('../lib/verify-typescript-setup'), {
             exposedMethods: [
-                'verifyAndRunTypeScript'
+                'verifyAndRunTypeScriptInWorker'
             ],
             debuggerPortOffset: -1,
             isolatedMemory: false,
@@ -81,10 +81,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
             enableWorkerThreads,
             maxRetries: 0
         });
-        impl = typeCheckWorker.verifyAndRunTypeScript;
+        impl = typeCheckWorker.verifyAndRunTypeScriptInWorker;
     } else {
-        // When not running typecheck, just run the implementation in-process without spawning a worker,
-        // to avoid the overhead of the worker.
+        // No worker: either we are not type-checking (just writing setup files), or
+        // the CLI checker runs `tsc` in-process. Avoid the worker overhead.
         impl = require('../lib/verify-typescript-setup').verifyAndRunTypeScript;
     }
     return impl({
@@ -100,18 +100,23 @@ function _interop_require_wildcard(obj, nodeInterop) {
         hasPagesDir,
         appDir,
         pagesDir,
-        debugBuildPaths
+        debugBuildPaths,
+        useTypeScriptCli,
+        onFirstCliOutput
     }).then((result)=>{
         typeCheckWorker == null ? void 0 : typeCheckWorker.end();
         return result;
     }).catch(()=>{
-        // The error is already logged in the worker, we simply exit the main thread to prevent the
-        // `Jest worker encountered 1 child process exceptions, exceeding retry limit` from showing up
+        // The error is already logged (in the worker for the API checker, or
+        // directly for the in-process CLI checker); we simply exit to prevent the
+        // `Jest worker encountered 1 child process exceptions, exceeding retry
+        // limit` message from showing up.
         process.exit(1);
     });
 }
 async function startTypeChecking({ cacheDir, config, dir, nextBuildSpan, pagesDir, telemetry, appDir, debugBuildPaths }) {
     const ignoreTypeScriptErrors = Boolean(config.typescript.ignoreBuildErrors);
+    const useTypeScriptCli = Boolean(config.experimental.useTypeScriptCli);
     if (ignoreTypeScriptErrors) {
         _log.info('Skipping validation of types');
     }
@@ -126,7 +131,8 @@ async function startTypeChecking({ cacheDir, config, dir, nextBuildSpan, pagesDi
     const typeCheckAndLintStart = process.hrtime();
     try {
         var _createSpinner;
-        const [verifyResult, typeCheckEnd] = await nextBuildSpan.traceChild('run-typescript').traceAsyncFn(()=>verifyAndRunTypeScript(dir, config.distDir, Boolean(config.experimental.strictRouteTypes), !ignoreTypeScriptErrors, config.typescript.tsconfigPath, Boolean(config.typedRoutes), config.images.disableStaticImages, cacheDir, config.experimental.workerThreads, !!appDir, !!pagesDir, appDir, pagesDir, debugBuildPaths).then((resolved)=>{
+        const [verifyResult, typeCheckEnd] = await nextBuildSpan.traceChild('run-typescript').traceAsyncFn(()=>verifyAndRunTypeScript(dir, config.distDir, Boolean(config.experimental.strictRouteTypes), !ignoreTypeScriptErrors, config.typescript.tsconfigPath, Boolean(config.typedRoutes), config.images.disableStaticImages, cacheDir, config.experimental.workerThreads, !!appDir, !!pagesDir, appDir, pagesDir, debugBuildPaths, useTypeScriptCli, // Stop the spinner before as soon as the subprocess reports output.
+            useTypeScriptCli && typeCheckingSpinner ? ()=>typeCheckingSpinner.stop() : undefined).then((resolved)=>{
                 const checkEnd = process.hrtime(typeCheckAndLintStart);
                 return [
                     resolved,
@@ -144,7 +150,8 @@ async function startTypeChecking({ cacheDir, config, dir, nextBuildSpan, pagesDi
                 typescriptVersion: verifyResult.version,
                 inputFilesCount: (_verifyResult_result = verifyResult.result) == null ? void 0 : _verifyResult_result.inputFilesCount,
                 totalFilesCount: (_verifyResult_result1 = verifyResult.result) == null ? void 0 : _verifyResult_result1.totalFilesCount,
-                incremental: (_verifyResult_result2 = verifyResult.result) == null ? void 0 : _verifyResult_result2.incremental
+                incremental: (_verifyResult_result2 = verifyResult.result) == null ? void 0 : _verifyResult_result2.incremental,
+                typeCheckMode: verifyResult.typeCheckMode
             }));
         }
     } catch (err) {

package/dist/build/type-check.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/build/type-check.ts"],"sourcesContent":["import type { NextConfigComplete } from '../server/config-shared'\nimport type { Telemetry } from '../telemetry/storage'\nimport type { Span } from '../trace'\n\nimport * as Log from './output/log'\nimport { Worker } from '../lib/worker'\nimport createSpinner from './spinner'\nimport { eventTypeCheckCompleted } from '../telemetry/events'\nimport isError from '../lib/is-error'\nimport { hrtimeDurationToString } from './duration-to-string'\n\n/**\n * typescript will be loaded in \"next/lib/verify-typescript-setup\" and\n * then passed to \"next/lib/typescript/runTypeCheck\" as a parameter.\n *\n * Since it is impossible to pass a function from main thread to a worker,\n * instead of running \"next/lib/typescript/runTypeCheck\" in a worker,\n * we will run entire \"next/lib/verify-typescript-setup\" in a worker instead.\n */\nfunction verifyAndRunTypeScript(\n  dir: string,\n  distDir: string,\n  strictRouteTypes: boolean,\n  shouldRunTypeCheck: boolean,\n  tsconfigPath: string | undefined,\n  typedRoutes: boolean,\n  disableStaticImages: boolean,\n  cacheDir: string | undefined,\n  enableWorkerThreads: boolean | undefined,\n  hasAppDir: boolean,\n  hasPagesDir: boolean,\n  appDir: string | undefined,\n  pagesDir: string | undefined,\n  debugBuildPaths: { app: string[]; pages: string[] } | undefined\n) {\n  let impl: typeof import('../lib/verify-typescript-setup').verifyAndRunTypeScript\n  let typeCheckWorker:\n    | (Worker & {\n        verifyAndRunTypeScript: typeof impl\n      })\n    | undefined\n  if (shouldRunTypeCheck) {\n    typeCheckWorker = new Worker(\n      require.resolve('../lib/verify-typescript-setup'),\n      {\n        exposedMethods: ['verifyAndRunTypeScript'],\n        debuggerPortOffset: -1,\n        isolatedMemory: false,\n        numWorkers: 1,\n        enableWorkerThreads,\n        maxRetries: 0,\n      }\n    ) as typeof typeCheckWorker\n    impl = typeCheckWorker!.verifyAndRunTypeScript\n  } else {\n    // When not running typecheck, just run the implementation in-process without spawning a worker,\n    // to avoid the overhead of the worker.\n    impl = (\n      require('../lib/verify-typescript-setup') as typeof import('../lib/verify-typescript-setup')\n    ).verifyAndRunTypeScript\n  }\n\n  return impl({\n    dir,\n    distDir,\n    strictRouteTypes,\n    shouldRunTypeCheck,\n    tsconfigPath,\n    typedRoutes,\n    disableStaticImages,\n    cacheDir,\n    hasAppDir,\n    hasPagesDir,\n    appDir,\n    pagesDir,\n    debugBuildPaths,\n  })\n    .then((result) => {\n      typeCheckWorker?.end()\n      return result\n    })\n    .catch(() => {\n      // The error is already logged in the worker, we simply exit the main thread to prevent the\n      // `Jest worker encountered 1 child process exceptions, exceeding retry limit` from showing up\n      process.exit(1)\n    })\n}\n\nexport async function startTypeChecking({\n  cacheDir,\n  config,\n  dir,\n  nextBuildSpan,\n  pagesDir,\n  telemetry,\n  appDir,\n  debugBuildPaths,\n}: {\n  cacheDir: string\n  config: NextConfigComplete\n  dir: string\n  nextBuildSpan: Span\n  pagesDir?: string\n  telemetry: Telemetry\n  appDir?: string\n  debugBuildPaths: { app: string[]; pages: string[] } | undefined\n}) {\n  const ignoreTypeScriptErrors = Boolean(config.typescript.ignoreBuildErrors)\n\n  if (ignoreTypeScriptErrors) {\n    Log.info('Skipping validation of types')\n  }\n\n  let typeCheckingSpinnerPrefixText: string | undefined\n  let typeCheckingSpinner: ReturnType<typeof createSpinner> | undefined\n\n  if (!ignoreTypeScriptErrors) {\n    typeCheckingSpinnerPrefixText = 'Running TypeScript'\n  }\n\n  if (typeCheckingSpinnerPrefixText) {\n    typeCheckingSpinner = createSpinner(typeCheckingSpinnerPrefixText)\n  }\n\n  const typeCheckAndLintStart = process.hrtime()\n\n  try {\n    const [verifyResult, typeCheckEnd] = await nextBuildSpan\n      .traceChild('run-typescript')\n      .traceAsyncFn(() =>\n        verifyAndRunTypeScript(\n          dir,\n          config.distDir,\n          Boolean(config.experimental.strictRouteTypes),\n          !ignoreTypeScriptErrors,\n          config.typescript.tsconfigPath,\n          Boolean(config.typedRoutes),\n          config.images.disableStaticImages,\n          cacheDir,\n          config.experimental.workerThreads,\n          !!appDir,\n          !!pagesDir,\n          appDir,\n          pagesDir,\n          debugBuildPaths\n        ).then((resolved) => {\n          const checkEnd = process.hrtime(typeCheckAndLintStart)\n          return [resolved, checkEnd] as const\n        })\n      )\n\n    if (typeCheckingSpinner) {\n      typeCheckingSpinner.stop()\n    }\n\n    createSpinner(\n      `Finished TypeScript${ignoreTypeScriptErrors ? ' config validation' : ''} in ${hrtimeDurationToString(typeCheckEnd)}`\n    )?.stopAndPersist()\n\n    if (!ignoreTypeScriptErrors && verifyResult) {\n      telemetry.record(\n        eventTypeCheckCompleted({\n          durationInSeconds: typeCheckEnd[0],\n          typescriptVersion: verifyResult.version,\n          inputFilesCount: verifyResult.result?.inputFilesCount,\n          totalFilesCount: verifyResult.result?.totalFilesCount,\n          incremental: verifyResult.result?.incremental,\n        })\n      )\n    }\n  } catch (err) {\n    // prevent showing jest-worker internal error as it\n    // isn't helpful for users and clutters output\n    if (isError(err) && err.message === 'Call retries were exceeded') {\n      await telemetry.flush()\n      process.exit(1)\n    }\n    throw err\n  }\n}\n"],"names":["startTypeChecking","verifyAndRunTypeScript","dir","distDir","strictRouteTypes","shouldRunTypeCheck","tsconfigPath","typedRoutes","disableStaticImages","cacheDir","enableWorkerThreads","hasAppDir","hasPagesDir","appDir","pagesDir","debugBuildPaths","impl","typeCheckWorker","Worker","require","resolve","exposedMethods","debuggerPortOffset","isolatedMemory","numWorkers","maxRetries","then","result","end","catch","process","exit","config","nextBuildSpan","telemetry","ignoreTypeScriptErrors","Boolean","typescript","ignoreBuildErrors","Log","info","typeCheckingSpinnerPrefixText","typeCheckingSpinner","createSpinner","typeCheckAndLintStart","hrtime","verifyResult","typeCheckEnd","traceChild","traceAsyncFn","experimental","images","workerThreads","resolved","checkEnd","stop","hrtimeDurationToString","stopAndPersist","record","eventTypeCheckCompleted","durationInSeconds","typescriptVersion","version","inputFilesCount","totalFilesCount","incremental","err","isError","message","flush"],"mappings":"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","ignoreList":[0]}
+{"version":3,"sources":["../../src/build/type-check.ts"],"sourcesContent":["import type { NextConfigComplete } from '../server/config-shared'\nimport type { Telemetry } from '../telemetry/storage'\nimport type { Span } from '../trace'\n\nimport * as Log from './output/log'\nimport { Worker } from '../lib/worker'\nimport createSpinner from './spinner'\nimport { eventTypeCheckCompleted } from '../telemetry/events'\nimport isError from '../lib/is-error'\nimport { hrtimeDurationToString } from './duration-to-string'\n\n/**\n * TypeScript setup and type checking run in a worker so the compiler's memory\n * can be released before the rest of the build continues.\n *\n * Since it is impossible to pass a function from main thread to a worker,\n * instead of running \"next/lib/typescript/runTypeCheck\" in a worker,\n * we will run entire \"next/lib/verify-typescript-setup\" in a worker instead.\n */\nfunction verifyAndRunTypeScript(\n  dir: string,\n  distDir: string,\n  strictRouteTypes: boolean,\n  shouldRunTypeCheck: boolean,\n  tsconfigPath: string | undefined,\n  typedRoutes: boolean,\n  disableStaticImages: boolean,\n  cacheDir: string | undefined,\n  enableWorkerThreads: boolean | undefined,\n  hasAppDir: boolean,\n  hasPagesDir: boolean,\n  appDir: string | undefined,\n  pagesDir: string | undefined,\n  debugBuildPaths: { app: string[]; pages: string[] } | undefined,\n  useTypeScriptCli: boolean,\n  onFirstCliOutput?: () => void\n) {\n  let impl: typeof import('../lib/verify-typescript-setup').verifyAndRunTypeScript\n  let typeCheckWorker:\n    | (Worker & {\n        verifyAndRunTypeScriptInWorker: typeof impl\n      })\n    | undefined\n  if (shouldRunTypeCheck && !useTypeScriptCli) {\n    typeCheckWorker = new Worker(\n      require.resolve('../lib/verify-typescript-setup'),\n      {\n        exposedMethods: ['verifyAndRunTypeScriptInWorker'],\n        debuggerPortOffset: -1,\n        isolatedMemory: false,\n        numWorkers: 1,\n        enableWorkerThreads,\n        maxRetries: 0,\n      }\n    ) as typeof typeCheckWorker\n    impl = typeCheckWorker!.verifyAndRunTypeScriptInWorker\n  } else {\n    // No worker: either we are not type-checking (just writing setup files), or\n    // the CLI checker runs `tsc` in-process. Avoid the worker overhead.\n    impl = (\n      require('../lib/verify-typescript-setup') as typeof import('../lib/verify-typescript-setup')\n    ).verifyAndRunTypeScript\n  }\n\n  return impl({\n    dir,\n    distDir,\n    strictRouteTypes,\n    shouldRunTypeCheck,\n    tsconfigPath,\n    typedRoutes,\n    disableStaticImages,\n    cacheDir,\n    hasAppDir,\n    hasPagesDir,\n    appDir,\n    pagesDir,\n    debugBuildPaths,\n    useTypeScriptCli,\n    onFirstCliOutput,\n  })\n    .then((result) => {\n      typeCheckWorker?.end()\n      return result\n    })\n    .catch(() => {\n      // The error is already logged (in the worker for the API checker, or\n      // directly for the in-process CLI checker); we simply exit to prevent the\n      // `Jest worker encountered 1 child process exceptions, exceeding retry\n      // limit` message from showing up.\n      process.exit(1)\n    })\n}\n\nexport async function startTypeChecking({\n  cacheDir,\n  config,\n  dir,\n  nextBuildSpan,\n  pagesDir,\n  telemetry,\n  appDir,\n  debugBuildPaths,\n}: {\n  cacheDir: string\n  config: NextConfigComplete\n  dir: string\n  nextBuildSpan: Span\n  pagesDir?: string\n  telemetry: Telemetry\n  appDir?: string\n  debugBuildPaths: { app: string[]; pages: string[] } | undefined\n}) {\n  const ignoreTypeScriptErrors = Boolean(config.typescript.ignoreBuildErrors)\n  const useTypeScriptCli = Boolean(config.experimental.useTypeScriptCli)\n\n  if (ignoreTypeScriptErrors) {\n    Log.info('Skipping validation of types')\n  }\n\n  let typeCheckingSpinnerPrefixText: string | undefined\n  let typeCheckingSpinner: ReturnType<typeof createSpinner> | undefined\n\n  if (!ignoreTypeScriptErrors) {\n    typeCheckingSpinnerPrefixText = 'Running TypeScript'\n  }\n\n  if (typeCheckingSpinnerPrefixText) {\n    typeCheckingSpinner = createSpinner(typeCheckingSpinnerPrefixText)\n  }\n\n  const typeCheckAndLintStart = process.hrtime()\n\n  try {\n    const [verifyResult, typeCheckEnd] = await nextBuildSpan\n      .traceChild('run-typescript')\n      .traceAsyncFn(() =>\n        verifyAndRunTypeScript(\n          dir,\n          config.distDir,\n          Boolean(config.experimental.strictRouteTypes),\n          !ignoreTypeScriptErrors,\n          config.typescript.tsconfigPath,\n          Boolean(config.typedRoutes),\n          config.images.disableStaticImages,\n          cacheDir,\n          config.experimental.workerThreads,\n          !!appDir,\n          !!pagesDir,\n          appDir,\n          pagesDir,\n          debugBuildPaths,\n          useTypeScriptCli,\n          // Stop the spinner before as soon as the subprocess reports output.\n          useTypeScriptCli && typeCheckingSpinner\n            ? () => typeCheckingSpinner.stop()\n            : undefined\n        ).then((resolved) => {\n          const checkEnd = process.hrtime(typeCheckAndLintStart)\n          return [resolved, checkEnd] as const\n        })\n      )\n\n    if (typeCheckingSpinner) {\n      typeCheckingSpinner.stop()\n    }\n\n    createSpinner(\n      `Finished TypeScript${ignoreTypeScriptErrors ? ' config validation' : ''} in ${hrtimeDurationToString(typeCheckEnd)}`\n    )?.stopAndPersist()\n\n    if (!ignoreTypeScriptErrors && verifyResult) {\n      telemetry.record(\n        eventTypeCheckCompleted({\n          durationInSeconds: typeCheckEnd[0],\n          typescriptVersion: verifyResult.version,\n          inputFilesCount: verifyResult.result?.inputFilesCount,\n          totalFilesCount: verifyResult.result?.totalFilesCount,\n          incremental: verifyResult.result?.incremental,\n          typeCheckMode: verifyResult.typeCheckMode,\n        })\n      )\n    }\n  } catch (err) {\n    // prevent showing jest-worker internal error as it\n    // isn't helpful for users and clutters output\n    if (isError(err) && err.message === 'Call retries were exceeded') {\n      await telemetry.flush()\n      process.exit(1)\n    }\n    throw err\n  }\n}\n"],"names":["startTypeChecking","verifyAndRunTypeScript","dir","distDir","strictRouteTypes","shouldRunTypeCheck","tsconfigPath","typedRoutes","disableStaticImages","cacheDir","enableWorkerThreads","hasAppDir","hasPagesDir","appDir","pagesDir","debugBuildPaths","useTypeScriptCli","onFirstCliOutput","impl","typeCheckWorker","Worker","require","resolve","exposedMethods","debuggerPortOffset","isolatedMemory","numWorkers","maxRetries","verifyAndRunTypeScriptInWorker","then","result","end","catch","process","exit","config","nextBuildSpan","telemetry","ignoreTypeScriptErrors","Boolean","typescript","ignoreBuildErrors","experimental","Log","info","typeCheckingSpinnerPrefixText","typeCheckingSpinner","createSpinner","typeCheckAndLintStart","hrtime","verifyResult","typeCheckEnd","traceChild","traceAsyncFn","images","workerThreads","stop","undefined","resolved","checkEnd","hrtimeDurationToString","stopAndPersist","record","eventTypeCheckCompleted","durationInSeconds","typescriptVersion","version","inputFilesCount","totalFilesCount","incremental","typeCheckMode","err","isError","message","flush"],"mappings":";;;;+BA8FsBA;;;eAAAA;;;6DA1FD;wBACE;gEACG;wBACc;gEACpB;kCACmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvC;;;;;;;CAOC,GACD,SAASC,uBACPC,GAAW,EACXC,OAAe,EACfC,gBAAyB,EACzBC,kBAA2B,EAC3BC,YAAgC,EAChCC,WAAoB,EACpBC,mBAA4B,EAC5BC,QAA4B,EAC5BC,mBAAwC,EACxCC,SAAkB,EAClBC,WAAoB,EACpBC,MAA0B,EAC1BC,QAA4B,EAC5BC,eAA+D,EAC/DC,gBAAyB,EACzBC,gBAA6B;IAE7B,IAAIC;IACJ,IAAIC;IAKJ,IAAId,sBAAsB,CAACW,kBAAkB;QAC3CG,kBAAkB,IAAIC,cAAM,CAC1BC,QAAQC,OAAO,CAAC,mCAChB;YACEC,gBAAgB;gBAAC;aAAiC;YAClDC,oBAAoB,CAAC;YACrBC,gBAAgB;YAChBC,YAAY;YACZhB;YACAiB,YAAY;QACd;QAEFT,OAAOC,gBAAiBS,8BAA8B;IACxD,OAAO;QACL,4EAA4E;QAC5E,oEAAoE;QACpEV,OAAO,AACLG,QAAQ,kCACRpB,sBAAsB;IAC1B;IAEA,OAAOiB,KAAK;QACVhB;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAE;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;IACF,GACGY,IAAI,CAAC,CAACC;QACLX,mCAAAA,gBAAiBY,GAAG;QACpB,OAAOD;IACT,GACCE,KAAK,CAAC;QACL,qEAAqE;QACrE,0EAA0E;QAC1E,uEAAuE;QACvE,kCAAkC;QAClCC,QAAQC,IAAI,CAAC;IACf;AACJ;AAEO,eAAelC,kBAAkB,EACtCS,QAAQ,EACR0B,MAAM,EACNjC,GAAG,EACHkC,aAAa,EACbtB,QAAQ,EACRuB,SAAS,EACTxB,MAAM,EACNE,eAAe,EAUhB;IACC,MAAMuB,yBAAyBC,QAAQJ,OAAOK,UAAU,CAACC,iBAAiB;IAC1E,MAAMzB,mBAAmBuB,QAAQJ,OAAOO,YAAY,CAAC1B,gBAAgB;IAErE,IAAIsB,wBAAwB;QAC1BK,KAAIC,IAAI,CAAC;IACX;IAEA,IAAIC;IACJ,IAAIC;IAEJ,IAAI,CAACR,wBAAwB;QAC3BO,gCAAgC;IAClC;IAEA,IAAIA,+BAA+B;QACjCC,sBAAsBC,IAAAA,gBAAa,EAACF;IACtC;IAEA,MAAMG,wBAAwBf,QAAQgB,MAAM;IAE5C,IAAI;YAkCFF;QAjCA,MAAM,CAACG,cAAcC,aAAa,GAAG,MAAMf,cACxCgB,UAAU,CAAC,kBACXC,YAAY,CAAC,IACZpD,uBACEC,KACAiC,OAAOhC,OAAO,EACdoC,QAAQJ,OAAOO,YAAY,CAACtC,gBAAgB,GAC5C,CAACkC,wBACDH,OAAOK,UAAU,CAAClC,YAAY,EAC9BiC,QAAQJ,OAAO5B,WAAW,GAC1B4B,OAAOmB,MAAM,CAAC9C,mBAAmB,EACjCC,UACA0B,OAAOO,YAAY,CAACa,aAAa,EACjC,CAAC,CAAC1C,QACF,CAAC,CAACC,UACFD,QACAC,UACAC,iBACAC,kBACA,oEAAoE;YACpEA,oBAAoB8B,sBAChB,IAAMA,oBAAoBU,IAAI,KAC9BC,WACJ5B,IAAI,CAAC,CAAC6B;gBACN,MAAMC,WAAW1B,QAAQgB,MAAM,CAACD;gBAChC,OAAO;oBAACU;oBAAUC;iBAAS;YAC7B;QAGJ,IAAIb,qBAAqB;YACvBA,oBAAoBU,IAAI;QAC1B;SAEAT,iBAAAA,IAAAA,gBAAa,EACX,CAAC,mBAAmB,EAAET,yBAAyB,uBAAuB,GAAG,IAAI,EAAEsB,IAAAA,wCAAsB,EAACT,eAAe,sBADvHJ,eAEGc,cAAc;QAEjB,IAAI,CAACvB,0BAA0BY,cAAc;gBAKtBA,sBACAA,uBACJA;YANjBb,UAAUyB,MAAM,CACdC,IAAAA,+BAAuB,EAAC;gBACtBC,mBAAmBb,YAAY,CAAC,EAAE;gBAClCc,mBAAmBf,aAAagB,OAAO;gBACvCC,eAAe,GAAEjB,uBAAAA,aAAapB,MAAM,qBAAnBoB,qBAAqBiB,eAAe;gBACrDC,eAAe,GAAElB,wBAAAA,aAAapB,MAAM,qBAAnBoB,sBAAqBkB,eAAe;gBACrDC,WAAW,GAAEnB,wBAAAA,aAAapB,MAAM,qBAAnBoB,sBAAqBmB,WAAW;gBAC7CC,eAAepB,aAAaoB,aAAa;YAC3C;QAEJ;IACF,EAAE,OAAOC,KAAK;QACZ,mDAAmD;QACnD,8CAA8C;QAC9C,IAAIC,IAAAA,gBAAO,EAACD,QAAQA,IAAIE,OAAO,KAAK,8BAA8B;YAChE,MAAMpC,UAAUqC,KAAK;YACrBzC,QAAQC,IAAI,CAAC;QACf;QACA,MAAMqC;IACR;AACF","ignoreList":[0]}

package/dist/build/webpack-config.js

@@ -1734,7 +1734,7 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
             isClient && new _copyfileplugin.CopyFilePlugin({
                 // file path to build output of `@next/polyfill-nomodule`
                 filePath: require.resolve('./polyfills/polyfill-nomodule'),
-                cacheKey: "16.2.11",
+                cacheKey: "16.2.12",
                 name: `static/chunks/polyfills${dev ? '' : '-[hash]'}.js`,
                 minimize: false,
                 info: {
@@ -1928,7 +1928,7 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
         //  - Next.js location on disk (some loaders use absolute paths and some resolve options depend on absolute paths)
         //  - Next.js version
         //  - next.config.js keys that affect compilation
-        version: `${__dirname}|${"16.2.11"}|${configVars}`,
+        version: `${__dirname}|${"16.2.12"}|${configVars}`,
         cacheDirectory: _path.default.join(distDir, 'cache', 'webpack'),
         // For production builds, it's more efficient to compress all cache files together instead of compression each one individually.
         // So we disable compression here and allow the build runner to take care of compressing the cache as a whole.
@@ -1984,7 +1984,7 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
                 type: 'filesystem',
                 directory: cache.cacheDirectory
             },
-            version: `${__dirname}|${"16.2.11"}|${configVars}`
+            version: `${__dirname}|${"16.2.12"}|${configVars}`
         };
     }
     if (process.env.NEXT_WEBPACK_LOGGING) {