@nx/js 23.1.0-pr.36127.8b9019b → 23.1.0-rc.0

package/dist/src/executors/prune-lockfile/prune-lockfile.d.ts

@@ -1,5 +1,7 @@
 import { type ExecutorContext } from '@nx/devkit';
+import { type PackageJson } from 'nx/src/utils/package-json';
 import { type PruneLockfileOptions } from './schema';
 export default function pruneLockfileExecutor(schema: PruneLockfileOptions, context: ExecutorContext): Promise<{
     success: boolean;
 }>;
+export declare function resolveCatalogReferences(packageJson: PackageJson): PackageJson;

package/dist/src/executors/prune-lockfile/prune-lockfile.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = pruneLockfileExecutor;
+exports.resolveCatalogReferences = resolveCatalogReferences;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const utils_1 = require("nx/src/tasks-runner/utils");
@@ -13,7 +15,8 @@ const strip_glob_to_base_dir_1 = require("../../utils/strip-glob-to-base-dir");
 async function pruneLockfileExecutor(schema, context) {
     devkit_1.logger.log('Pruning lockfile...');
     const outputDirectory = getOutputDir(schema, context);
-    const packageJson = getPackageJson(schema, context);
+    const packageJson = resolveCatalogReferences(getPackageJson(schema, context));
+    mergeAllowScripts(packageJson);
     const packageManager = (0, devkit_1.detectPackageManager)(devkit_1.workspaceRoot);
     if (packageManager === 'bun') {
         devkit_1.logger.warn('Bun lockfile generation is not supported. Only package.json will be generated. Run "bun install" in the output directory if needed.');
@@ -48,6 +51,55 @@ function createPrunedLockfile(packageJson, graph) {
         lockFile,
     };
 }
+/**
+ * npm reads the `allowScripts` install-script allowlist only from the install
+ * root, but `npm approve-scripts` writes it to the workspace root, so it never
+ * lives in the project package.json the prune output is built from. Carry the
+ * root allowlist over, with project-level entries preserved and winning on
+ * conflict. Mirrors the `pnpm.allowBuilds` handling in createPackageJson.
+ */
+function mergeAllowScripts(packageJson) {
+    const rootPackageJson = (0, devkit_1.readJsonFile)((0, path_1.join)(devkit_1.workspaceRoot, 'package.json'));
+    if (!rootPackageJson.allowScripts) {
+        return;
+    }
+    packageJson.allowScripts = {
+        ...rootPackageJson.allowScripts,
+        ...packageJson.allowScripts,
+    };
+}
+function resolveCatalogReferences(packageJson) {
+    const manager = (0, internal_1.getCatalogManager)(devkit_1.workspaceRoot);
+    if (!manager) {
+        return packageJson;
+    }
+    const sections = [
+        'dependencies',
+        'optionalDependencies',
+        'devDependencies',
+        'peerDependencies',
+    ];
+    const resolved = { ...packageJson };
+    for (const section of sections) {
+        const deps = packageJson[section];
+        if (!deps) {
+            continue;
+        }
+        const resolvedDeps = { ...deps };
+        for (const [packageName, version] of Object.entries(deps)) {
+            if (!manager.isCatalogReference(version)) {
+                continue;
+            }
+            const resolvedVersion = manager.resolveCatalogReference(devkit_1.workspaceRoot, packageName, version);
+            if (!resolvedVersion) {
+                throw new Error(`Could not resolve catalog reference for package ${packageName}@${version}.`);
+            }
+            resolvedDeps[packageName] = resolvedVersion;
+        }
+        resolved[section] = resolvedDeps;
+    }
+    return resolved;
+}
 function getPackageJson(schema, context) {
     const target = (0, devkit_1.parseTargetString)(schema.buildTarget, context);
     const project = context.projectGraph.nodes[target.project].data;

package/dist/src/executors/tsc/tsc.impl.js

@@ -55,8 +55,12 @@ function createTypeScriptCompilationOptions(normalizedOptions, context) {
         outputPath: (0, devkit_1.joinPathFragments)(normalizedOptions.outputPath),
         projectName: context.projectName,
         projectRoot: normalizedOptions.projectRoot,
-        rootDir: (0, devkit_1.joinPathFragments)(normalizedOptions.rootDir),
-        tsConfig: (0, devkit_1.joinPathFragments)(normalizedOptions.tsConfig),
+        // Keep the Windows drive letter on rootDir/tsConfig (only forward-slash them).
+        // joinPathFragments strips it via normalizePath, leaving them drive-less while
+        // the generated path mappings stay absolute drive-full, so alias-resolved files
+        // fail TypeScript's rootDir containment check (TS6059) on Windows.
+        rootDir: normalizedOptions.rootDir.replace(/\\/g, '/'),
+        tsConfig: normalizedOptions.tsConfig.replace(/\\/g, '/'),
         watch: normalizedOptions.watch,
         deleteOutputPath: normalizedOptions.clean,
         getCustomTransformers: (0, lib_1.getCustomTrasformersFactory)(normalizedOptions.transformers),

package/dist/src/generators/setup-build/generator.js

@@ -249,7 +249,5 @@ function updatePackageJson(tree, projectName, projectRoot, main, outputPath, roo
 function mergeTargetDefaults(tree, project, buildTarget) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const projectTarget = project.targets[buildTarget];
-    return (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, (projectTarget.executor
-        ? nxJson.targetDefaults?.[projectTarget.executor]
-        : undefined) ?? nxJson.targetDefaults?.[buildTarget]);
+    return (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, (0, internal_1.readTargetDefaultsForTarget)(buildTarget, nxJson.targetDefaults, projectTarget.executor));
 }

package/dist/src/migrations/update-22-0-0/remove-external-options-from-js-executors.js

@@ -35,30 +35,50 @@ async function default_1(tree) {
     if (!nxJson.targetDefaults) {
         return;
     }
-    for (const [targetOrExecutor, targetConfig] of Object.entries(nxJson.targetDefaults)) {
-        if (!exports.executors.includes(targetOrExecutor) &&
-            !exports.executors.includes(targetConfig.executor)) {
-            continue;
-        }
-        if (targetConfig.options) {
-            delete targetConfig.options.external;
-            delete targetConfig.options.externalBuildTargets;
-            if (!Object.keys(targetConfig.options).length) {
-                delete targetConfig.options;
+    const cleanEntry = (entry) => {
+        if (entry.options) {
+            delete entry.options.external;
+            delete entry.options.externalBuildTargets;
+            if (!Object.keys(entry.options).length) {
+                delete entry.options;
             }
         }
-        Object.entries(targetConfig.configurations ?? {}).forEach(([, config]) => {
+        Object.values(entry.configurations ?? {}).forEach((config) => {
             delete config.external;
             delete config.externalBuildTargets;
         });
-        if (!Object.keys(targetConfig).length ||
-            (Object.keys(targetConfig).length === 1 &&
-                Object.keys(targetConfig)[0] === 'executor')) {
-            delete nxJson.targetDefaults[targetOrExecutor];
+    };
+    const targetDefaults = nxJson.targetDefaults;
+    for (const key of Object.keys(targetDefaults)) {
+        const value = targetDefaults[key];
+        const entries = Array.isArray(value)
+            ? value
+            : [value];
+        const usesExecutor = (entry) => exports.executors.includes(key) ||
+            exports.executors.includes(entry.executor) ||
+            exports.executors.includes(entry.filter?.executor);
+        const kept = entries.filter((entry) => {
+            if (usesExecutor(entry)) {
+                cleanEntry(entry);
+            }
+            // Drop entries left with nothing but their `filter`/`executor` locator.
+            return Object.keys(entry).some((k) => k !== 'filter' && k !== 'executor');
+        });
+        if (kept.length === 0) {
+            delete targetDefaults[key];
         }
-        if (!Object.keys(nxJson.targetDefaults).length) {
-            delete nxJson.targetDefaults;
+        else if (kept.length === 1 && kept[0].filter === undefined) {
+            // A lone unfiltered entry is stored as the plain object form (which
+            // omits `filter`).
+            const { filter: _filter, ...config } = kept[0];
+            targetDefaults[key] = config;
         }
+        else {
+            targetDefaults[key] = kept;
+        }
+    }
+    if (Object.keys(targetDefaults).length === 0) {
+        delete nxJson.targetDefaults;
     }
     (0, devkit_1.updateNxJson)(tree, nxJson);
     await (0, devkit_1.formatFiles)(tree);

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.d.ts

@@ -1,28 +1,43 @@
 import { type Tree } from '@nx/devkit';
 /**
- * Two independent passes over every tsconfig*.json in the workspace:
+ * Runs on TypeScript 6 workspaces (gated by `requires` in migrations.json) in
+ * two passes over every `tsconfig*.json`.
  *
- * 1. ignoreDeprecations pass - adds `ignoreDeprecations: "6.0"` to any
- *    compilerOptions (or ts-node.compilerOptions) block that directly carries a
- *    TS6 hard-deprecated option value (moduleResolution node/node10/classic,
- *    baseUrl, target es5, esModuleInterop false, outFile, module
- *    amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports
- *    false, downlevelIteration set to any value).
+ * Pass 1 writes what pass 2's `extends` resolution reads back:
+ *  - Default-preserving pins: on every chain root (no `extends`) that is not a
+ *    pure solution container (`files: []` with no `include`), pin the TS6
+ *    defaults that changed in a breaking way, but only where the root leaves
+ *    them unset:
+ *      - `strict: false`. TS6 treats an absent `strict` as true, TS5 as false.
+ *      - `noUncheckedSideEffectImports: false`. TS6 defaults it true, turning a
+ *        bare side-effect import of an asset without an ambient declaration
+ *        (`import './styles.css'`) into a hard TS2882; a semantic diagnostic,
+ *        not a deprecation, so `ignoreDeprecations` cannot silence it.
+ *      - `types: ["*"]`. TS6 loads no @types when `types` is unset (TS5 loaded
+ *        all); the wildcard restores that so a config relying on it (ts-node
+ *        type-checking jest.config.ts) keeps finding @types/node.
+ *      - `esModuleInterop: false`. TS6 flips the default false->true, changing
+ *        `import * as x from '<cjs>'` call semantics at runtime; false preserves
+ *        the pre-TS6 behavior. It is itself deprecated (removed in TS7), so pass
+ *        2 silences it, deferring the interop change to the eventual TS7 work.
+ *  - Config-load flag: set `ignoreDeprecations: "6.0"` on every file named
+ *    exactly `tsconfig.json`, the name jest/ts-node auto-resolve (walking up
+ *    from the file they compile, such as jest.config.ts). ts-node injects a
+ *    `target: es5` when the config leaves it unset, and es5 is a TS6-deprecated
+ *    value (TS5107); the flag (which ts-node passes through) keeps that load
+ *    silent. Set unconditionally, since any `tsconfig.json` is a potential
+ *    loader target, and inert when nothing is deprecated. It cannot silence a
+ *    module/moduleResolution mismatch (TS5110) when ts-node's forced
+ *    `module: commonjs` meets an inherited `nodenext` resolution.
  *
- * 2. default-preserving pass - for every chain root (no "extends" key), pins
- *    the TS6 compiler-option defaults that flipped to a stricter value back to
- *    their pre-TS6 value, but only when the root does not set them explicitly:
- *      - "strict": false - TS6 treats an absent "strict" as true; TS5 as false.
- *      - "noUncheckedSideEffectImports": false - TS6 defaults it to true, which
- *        turns a bare side-effect import of an asset lacking an ambient
- *        declaration (e.g. `import './styles.css'`) into a hard TS2882 error; it
- *        is a semantic diagnostic, not a deprecation, so `ignoreDeprecations`
- *        cannot silence it.
- *    Files with "extends" inherit from their chain root and are left untouched.
- *    Pure solution-style containers (root has `"files": []` and no "include")
- *    select no source files, so pinning there is noise and they are skipped.
- *
- * Only runs on TS6 workspaces (gated by `requires` in migrations.json), because
- * `ignoreDeprecations: "6.0"` is itself a hard error (TS5103) on TS 5.x.
+ * Pass 2 silences the remaining hard-deprecated values. For each config,
+ * TypeScript resolves its `extends`-merged compiler options; when they carry a
+ * value TS6 hard-deprecates (see `hasDeprecatedOption`) and their effective
+ * `ignoreDeprecations` is not already `"6.0"`, add the flag. Because the check
+ * runs on the merged options, it covers a value the config inherits from a base
+ * this migration never edits, respects an inherited `"6.0"` (no redundant flag),
+ * and upgrades a stale local `"5.0"` that overrides one. The
+ * `ts-node.compilerOptions` overlay, which `tsc` does not merge, is checked on
+ * its own.
  */
 export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.js

@@ -4,192 +4,256 @@ exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
 const node_path_1 = require("node:path");
 const jsonc_parser_1 = require("jsonc-parser");
+const ensure_typescript_1 = require("../../utils/typescript/ensure-typescript");
 const FORMATTING_OPTIONS = {
     formattingOptions: { keepLines: true, insertSpaces: true, tabSize: 2 },
 };
+let tsModule;
 /**
- * Two independent passes over every tsconfig*.json in the workspace:
+ * Runs on TypeScript 6 workspaces (gated by `requires` in migrations.json) in
+ * two passes over every `tsconfig*.json`.
  *
- * 1. ignoreDeprecations pass - adds `ignoreDeprecations: "6.0"` to any
- *    compilerOptions (or ts-node.compilerOptions) block that directly carries a
- *    TS6 hard-deprecated option value (moduleResolution node/node10/classic,
- *    baseUrl, target es5, esModuleInterop false, outFile, module
- *    amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports
- *    false, downlevelIteration set to any value).
+ * Pass 1 writes what pass 2's `extends` resolution reads back:
+ *  - Default-preserving pins: on every chain root (no `extends`) that is not a
+ *    pure solution container (`files: []` with no `include`), pin the TS6
+ *    defaults that changed in a breaking way, but only where the root leaves
+ *    them unset:
+ *      - `strict: false`. TS6 treats an absent `strict` as true, TS5 as false.
+ *      - `noUncheckedSideEffectImports: false`. TS6 defaults it true, turning a
+ *        bare side-effect import of an asset without an ambient declaration
+ *        (`import './styles.css'`) into a hard TS2882; a semantic diagnostic,
+ *        not a deprecation, so `ignoreDeprecations` cannot silence it.
+ *      - `types: ["*"]`. TS6 loads no @types when `types` is unset (TS5 loaded
+ *        all); the wildcard restores that so a config relying on it (ts-node
+ *        type-checking jest.config.ts) keeps finding @types/node.
+ *      - `esModuleInterop: false`. TS6 flips the default false->true, changing
+ *        `import * as x from '<cjs>'` call semantics at runtime; false preserves
+ *        the pre-TS6 behavior. It is itself deprecated (removed in TS7), so pass
+ *        2 silences it, deferring the interop change to the eventual TS7 work.
+ *  - Config-load flag: set `ignoreDeprecations: "6.0"` on every file named
+ *    exactly `tsconfig.json`, the name jest/ts-node auto-resolve (walking up
+ *    from the file they compile, such as jest.config.ts). ts-node injects a
+ *    `target: es5` when the config leaves it unset, and es5 is a TS6-deprecated
+ *    value (TS5107); the flag (which ts-node passes through) keeps that load
+ *    silent. Set unconditionally, since any `tsconfig.json` is a potential
+ *    loader target, and inert when nothing is deprecated. It cannot silence a
+ *    module/moduleResolution mismatch (TS5110) when ts-node's forced
+ *    `module: commonjs` meets an inherited `nodenext` resolution.
  *
- * 2. default-preserving pass - for every chain root (no "extends" key), pins
- *    the TS6 compiler-option defaults that flipped to a stricter value back to
- *    their pre-TS6 value, but only when the root does not set them explicitly:
- *      - "strict": false - TS6 treats an absent "strict" as true; TS5 as false.
- *      - "noUncheckedSideEffectImports": false - TS6 defaults it to true, which
- *        turns a bare side-effect import of an asset lacking an ambient
- *        declaration (e.g. `import './styles.css'`) into a hard TS2882 error; it
- *        is a semantic diagnostic, not a deprecation, so `ignoreDeprecations`
- *        cannot silence it.
- *    Files with "extends" inherit from their chain root and are left untouched.
- *    Pure solution-style containers (root has `"files": []` and no "include")
- *    select no source files, so pinning there is noise and they are skipped.
- *
- * Only runs on TS6 workspaces (gated by `requires` in migrations.json), because
- * `ignoreDeprecations: "6.0"` is itself a hard error (TS5103) on TS 5.x.
+ * Pass 2 silences the remaining hard-deprecated values. For each config,
+ * TypeScript resolves its `extends`-merged compiler options; when they carry a
+ * value TS6 hard-deprecates (see `hasDeprecatedOption`) and their effective
+ * `ignoreDeprecations` is not already `"6.0"`, add the flag. Because the check
+ * runs on the merged options, it covers a value the config inherits from a base
+ * this migration never edits, respects an inherited `"6.0"` (no redundant flag),
+ * and upgrades a stale local `"5.0"` that overrides one. The
+ * `ts-node.compilerOptions` overlay, which `tsc` does not merge, is checked on
+ * its own.
  */
 async function default_1(tree) {
-    let deprecationCount = 0;
+    tsModule ??= (0, ensure_typescript_1.ensureTypescript)();
+    const ts = tsModule;
+    // Tree-backed host so TypeScript resolves `extends` against pass 1's pending
+    // writes; the `readDirectory` no-op skips the source-file scan, since only the
+    // merged compiler options matter here, not the file list.
+    const parseHost = {
+        ...ts.sys,
+        readFile: (filePath) => tree.read(filePath, 'utf-8') ?? undefined,
+        readDirectory: () => [],
+    };
+    const tsconfigPaths = await (0, devkit_1.globAsync)(tree, ['**/tsconfig*.json']);
+    // Pass 1: pins and config-load flags, so pass 2's inheritance check sees them.
     let defaultsPinCount = 0;
-    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
-        const name = (0, node_path_1.basename)(filePath);
-        if (!name.startsWith('tsconfig') || !name.endsWith('.json')) {
-            return;
-        }
-        if (addIgnoreDeprecations(tree, filePath)) {
-            deprecationCount += 1;
-        }
-        if (pinPreTs6Defaults(tree, filePath)) {
+    let configLoadCount = 0;
+    for (const tsconfigPath of tsconfigPaths) {
+        const { pinned, flagged } = applyDefaultsAndConfigLoadFlag(tree, tsconfigPath);
+        if (pinned)
             defaultsPinCount += 1;
+        if (flagged)
+            configLoadCount += 1;
+    }
+    // Pass 2: silence a deprecated value the config carries or inherits.
+    let deprecationCount = 0;
+    for (const tsconfigPath of tsconfigPaths) {
+        if (silenceDeprecations(tree, ts, parseHost, tsconfigPath)) {
+            deprecationCount += 1;
         }
-    });
+    }
+    if (configLoadCount > 0) {
+        devkit_1.logger.info(`Ensured "ignoreDeprecations": "6.0" on ${configLoadCount} "tsconfig.json" file(s) so config loaders (jest/ts-node) keep working on TypeScript 6.`);
+    }
     if (deprecationCount > 0) {
         devkit_1.logger.info(`Added "ignoreDeprecations": "6.0" to ${deprecationCount} tsconfig file(s) carrying TS6-deprecated options.`);
     }
     if (defaultsPinCount > 0) {
-        devkit_1.logger.info(`Pinned pre-TS6 compiler option defaults ("strict", "noUncheckedSideEffectImports") on ${defaultsPinCount} tsconfig chain root(s) to preserve existing behavior.`);
+        devkit_1.logger.info(`Pinned pre-TS6 compiler option defaults ("strict", "noUncheckedSideEffectImports", "types", "esModuleInterop") on ${defaultsPinCount} tsconfig chain root(s).`);
     }
     await (0, devkit_1.formatFiles)(tree);
 }
-function addIgnoreDeprecations(tree, tsconfigPath) {
+// The pre-TS6 default values pinned on chain roots that leave them unset; pass 1
+// above explains why each one changed in a breaking way.
+const DEFAULT_PRESERVING_PINS = [
+    ['strict', false],
+    ['noUncheckedSideEffectImports', false],
+    ['types', ['*']],
+    ['esModuleInterop', false],
+];
+// Pass 1 for one file: pin pre-TS6 defaults on a chain root and set the
+// config-load flag on a `tsconfig.json`, combined into a single write.
+function applyDefaultsAndConfigLoadFlag(tree, tsconfigPath) {
     const original = tree.read(tsconfigPath, 'utf-8');
     if (!original) {
+        return { pinned: false, flagged: false };
+    }
+    const root = (0, jsonc_parser_1.parseTree)(original);
+    if (!root || root.type !== 'object') {
+        return { pinned: false, flagged: false };
+    }
+    const own = (0, jsonc_parser_1.getNodeValue)(root);
+    const compilerOptions = own.compilerOptions;
+    // A present-but-non-object compilerOptions can't receive keys; leave the file
+    // alone so modify() doesn't throw and abort the whole migration.
+    if (compilerOptions !== undefined && !isObject(compilerOptions)) {
+        return { pinned: false, flagged: false };
+    }
+    const options = (compilerOptions ?? {});
+    let contents = original;
+    let pinned = false;
+    let flagged = false;
+    // Only chain roots; a file with "extends" inherits the defaults. Skip pure
+    // solution containers ("files": [] and no "include"): they select no sources.
+    const isSolutionContainer = Array.isArray(own.files) && own.files.length === 0 && !('include' in own);
+    if (own.extends === undefined && !isSolutionContainer) {
+        for (const [key, value] of DEFAULT_PRESERVING_PINS) {
+            if (key in options)
+                continue; // An explicit value means the user opted in.
+            contents = (0, jsonc_parser_1.applyEdits)(contents, (0, jsonc_parser_1.modify)(contents, ['compilerOptions', key], value, FORMATTING_OPTIONS));
+            pinned = true;
+        }
+    }
+    if ((0, node_path_1.basename)(tsconfigPath) === 'tsconfig.json' &&
+        options.ignoreDeprecations !== '6.0') {
+        contents = (0, jsonc_parser_1.applyEdits)(contents, (0, jsonc_parser_1.modify)(contents, ['compilerOptions', 'ignoreDeprecations'], '6.0', FORMATTING_OPTIONS));
+        flagged = true;
+    }
+    if (pinned || flagged) {
+        tree.write(tsconfigPath, contents);
+    }
+    return { pinned, flagged };
+}
+// Pass 2 for one file: silence a deprecated value it carries or inherits, in the
+// main block and the ts-node overlay, combined into a single write.
+function silenceDeprecations(tree, ts, parseHost, tsconfigPath) {
+    const original = tree.read(tsconfigPath, 'utf-8');
+    if (!original) {
+        return false;
+    }
+    const root = (0, jsonc_parser_1.parseTree)(original);
+    if (!root || root.type !== 'object') {
+        return false;
+    }
+    const own = (0, jsonc_parser_1.getNodeValue)(root);
+    const mainBlock = own.compilerOptions;
+    const mainIsObject = isObject(mainBlock);
+    const mainFlag = mainIsObject
+        ? mainBlock.ignoreDeprecations
+        : undefined;
+    const tsNodeBlock = isObject(own['ts-node'])
+        ? own['ts-node'].compilerOptions
+        : undefined;
+    const tsNodeIsObject = isObject(tsNodeBlock);
+    const tsNodeFlag = tsNodeIsObject
+        ? tsNodeBlock.ignoreDeprecations
+        : undefined;
+    // No own options and no `extends` to inherit through, and no overlay to check:
+    // nothing can be deprecated here, so skip without parsing.
+    if (!mainIsObject && own.extends === undefined && !tsNodeIsObject) {
         return false;
     }
-    // Each entry targets a distinct compilerOptions block within the same file.
-    const blocks = [
-        ['compilerOptions'],
-        ['ts-node', 'compilerOptions'],
-    ];
+    // Main is already silenced and there is no overlay: nothing to do, skip the
+    // parse entirely (the common case for a config-load-flagged `tsconfig.json`).
+    if (mainFlag === '6.0' && !tsNodeIsObject) {
+        return false;
+    }
+    // The `extends`-merged main options, normalized by TypeScript. Passing the
+    // config object (not the path) keeps TypeScript from re-reading this file; it
+    // reads only the ancestors.
+    const mainOptions = ts.parseJsonConfigFileContent({ extends: own.extends, compilerOptions: mainIsObject ? mainBlock : {} }, parseHost, (0, node_path_1.dirname)(tsconfigPath)).options;
+    const mainDeprecated = hasDeprecatedOption(ts, mainOptions);
     let contents = original;
     let changed = false;
-    for (const blockPath of blocks) {
-        // Re-parse each iteration: a prior edit shifts offsets in `contents`.
-        const root = (0, jsonc_parser_1.parseTree)(contents);
-        const blockNode = root && (0, jsonc_parser_1.findNodeAtLocation)(root, blockPath);
-        if (!blockNode || blockNode.type !== 'object') {
-            continue;
-        }
-        const compilerOptions = (0, jsonc_parser_1.getNodeValue)(blockNode);
-        if (!hasDeprecatedValue(compilerOptions)) {
-            continue;
-        }
-        // An existing non-"6.0" value (e.g. "5.0") does NOT silence 6.0-class
-        // deprecations, so upgrade it; only "6.0" is already correct.
-        if (compilerOptions.ignoreDeprecations === '6.0') {
-            continue;
-        }
-        const edits = (0, jsonc_parser_1.modify)(contents, [...blockPath, 'ignoreDeprecations'], '6.0', FORMATTING_OPTIONS);
-        contents = (0, jsonc_parser_1.applyEdits)(contents, edits);
+    // Main block: silence a deprecated value it carries or inherits, unless an
+    // effective "6.0" (own or inherited) already covers it. A stale local "5.0"
+    // that overrides an inherited "6.0" shows through the merge and is upgraded.
+    // An absent block is created; a present-but-non-object one is left alone so
+    // modify() neither corrupts it nor throws.
+    const mainWritable = mainBlock === undefined || mainIsObject;
+    if (mainWritable &&
+        mainFlag !== '6.0' &&
+        mainDeprecated &&
+        mainOptions.ignoreDeprecations !== '6.0') {
+        contents = (0, jsonc_parser_1.applyEdits)(contents, (0, jsonc_parser_1.modify)(contents, ['compilerOptions', 'ignoreDeprecations'], '6.0', FORMATTING_OPTIONS));
         changed = true;
     }
+    // ts-node overlay: `tsc` does not merge it, so check it directly. ts-node
+    // overlays the resolved main options at runtime; a "6.0" the main block just
+    // received does not reliably reach the overlay across ts-node versions, so
+    // silence it on its own whenever it or the resolved main carries a deprecated
+    // value.
+    if (tsNodeIsObject && tsNodeFlag !== '6.0') {
+        const overlayOptions = ts.parseJsonConfigFileContent({ compilerOptions: tsNodeBlock }, parseHost, (0, node_path_1.dirname)(tsconfigPath)).options;
+        if (hasDeprecatedOption(ts, overlayOptions) || mainDeprecated) {
+            contents = (0, jsonc_parser_1.applyEdits)(contents, (0, jsonc_parser_1.modify)(contents, ['ts-node', 'compilerOptions', 'ignoreDeprecations'], '6.0', FORMATTING_OPTIONS));
+            changed = true;
+        }
+    }
     if (changed) {
         tree.write(tsconfigPath, contents);
     }
     return changed;
 }
-// Values that compile silently on TS 5.8 but are hard deprecation errors
-// (TS5101/TS5107) on TS 6.0 - derived by differential 5.8-vs-6.0 probing.
-function hasDeprecatedValue(compilerOptions) {
-    const moduleResolution = asLowerString(compilerOptions.moduleResolution);
-    if (moduleResolution === 'node' ||
-        moduleResolution === 'node10' ||
-        moduleResolution === 'classic') {
+// Whether TypeScript-parsed, `extends`-merged compiler options carry a value
+// that compiles silently on TS 5.8 but is a hard deprecation error (TS5101/
+// TS5107) on TS 6.0, derived by differential 5.8-vs-6.0 probing. Options are
+// read from the normalized enums TypeScript produces; an unset option stays
+// undefined (TypeScript does not fill in the module-derived `moduleResolution`
+// default here), so an implied resolution is not misread as deprecated.
+function hasDeprecatedOption(ts, options) {
+    const moduleResolution = options.moduleResolution;
+    if (moduleResolution === ts.ModuleResolutionKind.Node10 ||
+        moduleResolution === ts.ModuleResolutionKind.Classic) {
         return true;
     }
-    // `baseUrl`/`outFile` only deprecate when set to a real value; `null`/unset
-    // is inert on TS6.
-    if (compilerOptions.baseUrl != null) {
+    if (options.baseUrl != null) {
         return true;
     }
-    if (asLowerString(compilerOptions.target) === 'es5') {
+    if (options.target === ts.ScriptTarget.ES5) {
         return true;
     }
-    if (compilerOptions.esModuleInterop === false) {
+    if (options.esModuleInterop === false) {
         return true;
     }
-    if (compilerOptions.outFile != null) {
+    if (options.outFile != null) {
         return true;
     }
-    const moduleValue = asLowerString(compilerOptions.module);
-    if (moduleValue === 'amd' ||
-        moduleValue === 'umd' ||
-        moduleValue === 'system' ||
-        moduleValue === 'none') {
+    const module = options.module;
+    if (module === ts.ModuleKind.AMD ||
+        module === ts.ModuleKind.UMD ||
+        module === ts.ModuleKind.System ||
+        module === ts.ModuleKind.None) {
         return true;
     }
-    // Only the explicit `false` value triggers TS5107 for these two flags.
-    if (compilerOptions.alwaysStrict === false) {
+    if (options.alwaysStrict === false) {
         return true;
     }
-    if (compilerOptions.allowSyntheticDefaultImports === false) {
+    if (options.allowSyntheticDefaultImports === false) {
         return true;
     }
-    // A real boolean triggers TS5101; `null`/unset is inert. `!= null` also flags
-    // non-boolean JSON, but that only adds a harmless no-op `ignoreDeprecations`.
-    if (compilerOptions.downlevelIteration != null) {
+    if (options.downlevelIteration != null) {
         return true;
     }
     return false;
 }
-// TS6 compiler-option defaults that flipped to a stricter value. We pin each
-// back to its pre-TS6 value on chain roots that don't set it, so existing
-// workspaces keep building without adopting a legit TS6 setup.
-const DEFAULT_PRESERVING_PINS = [
-    ['strict', false],
-    ['noUncheckedSideEffectImports', false],
-];
-function pinPreTs6Defaults(tree, tsconfigPath) {
-    const original = tree.read(tsconfigPath, 'utf-8');
-    if (!original) {
-        return false;
-    }
-    const root = (0, jsonc_parser_1.parseTree)(original);
-    if (!root || root.type !== 'object') {
-        return false;
-    }
-    const rootValue = (0, jsonc_parser_1.getNodeValue)(root);
-    // Only touch chain roots - files with "extends" inherit from their ancestor.
-    if ('extends' in rootValue) {
-        return false;
-    }
-    // Skip pure solution-style containers: root has "files": [] and no "include".
-    // They select no source files, so pinning defaults there is noise.
-    const filesNode = (0, jsonc_parser_1.findNodeAtLocation)(root, ['files']);
-    const hasEmptyFiles = filesNode?.type === 'array' && filesNode.children?.length === 0;
-    if (hasEmptyFiles && !('include' in rootValue)) {
-        return false;
-    }
-    const compilerOptionsNode = (0, jsonc_parser_1.findNodeAtLocation)(root, ['compilerOptions']);
-    // A present-but-non-object compilerOptions can't receive pinned keys; bailing
-    // avoids modify() throwing and aborting the whole migration.
-    if (compilerOptionsNode && compilerOptionsNode.type !== 'object') {
-        return false;
-    }
-    const compilerOptions = compilerOptionsNode
-        ? (0, jsonc_parser_1.getNodeValue)(compilerOptionsNode)
-        : {};
-    let contents = original;
-    let changed = false;
-    for (const [key, value] of DEFAULT_PRESERVING_PINS) {
-        // An explicit value (true or false) means the user opted in - leave it.
-        if (key in compilerOptions) {
-            continue;
-        }
-        const edits = (0, jsonc_parser_1.modify)(contents, ['compilerOptions', key], value, FORMATTING_OPTIONS);
-        contents = (0, jsonc_parser_1.applyEdits)(contents, edits);
-        changed = true;
-    }
-    if (changed) {
-        tree.write(tsconfigPath, contents);
-    }
-    return changed;
-}
-function asLowerString(value) {
-    return typeof value === 'string' ? value.toLowerCase() : undefined;
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.md

@@ -1,11 +1,12 @@
 #### Keep Existing Workspaces Compiling on TypeScript 6
 
-TypeScript 6 turns several long-deprecated compiler options into hard errors and flips a few option defaults to stricter values. So that an existing workspace keeps compiling on TypeScript 6 without being migrated to a full TypeScript 6 setup, this migration makes two edits to the `tsconfig*.json` files in the workspace:
+TypeScript 6 turns several long-deprecated compiler options into hard errors and flips a few option defaults to stricter values. So that an existing workspace keeps compiling on TypeScript 6 without being migrated to a full TypeScript 6 setup, this migration edits the `tsconfig*.json` files in the workspace:
 
-- Adds `"ignoreDeprecations": "6.0"` to any `compilerOptions` (or `ts-node.compilerOptions`) block that directly sets a TypeScript 6 deprecated option - for example `moduleResolution` set to `node`/`node10`/`classic`, `baseUrl`, `target` set to `es5`, `esModuleInterop: false`, `outFile`, `module` set to `amd`/`umd`/`system`/`none`, `alwaysStrict: false`, `allowSyntheticDefaultImports: false`, or `downlevelIteration`.
-- Pins `"strict": false` and `"noUncheckedSideEffectImports": false` on every chain-root tsconfig (one without an `extends`) that does not already set them. TypeScript 6 treats an absent `strict` as `true` (it was `false` when unset before) and defaults `noUncheckedSideEffectImports` to `true`, which turns a bare side-effect import such as `import './styles.css'` without an ambient module declaration into an error. Pinning both preserves the pre-TypeScript 6 behavior.
+- Adds `"ignoreDeprecations": "6.0"` to any `compilerOptions` (or `ts-node.compilerOptions`) block whose effective options carry a TypeScript 6 deprecated option, set directly or inherited through `extends` (including from a base this migration does not edit, such as a package-provided config). Examples: `moduleResolution` set to `node`/`node10`/`classic`, `baseUrl`, `target` set to `es5`, `esModuleInterop: false`, `outFile`, `module` set to `amd`/`umd`/`system`/`none`, `alwaysStrict: false`, `allowSyntheticDefaultImports: false`, or `downlevelIteration`. A block that already inherits an effective `"6.0"` and sets no local value is left alone; a stale local value such as `"5.0"` is upgraded to `"6.0"`, since it would otherwise override the inherited flag and still error.
+- Pins `"strict": false`, `"noUncheckedSideEffectImports": false`, `"types": ["*"]`, and `"esModuleInterop": false` on every chain-root tsconfig (one without an `extends`) that does not already set them. TypeScript 6 treats an absent `strict` as `true` (it was `false` when unset before), defaults `noUncheckedSideEffectImports` to `true` (which turns a bare side-effect import such as `import './styles.css'` without an ambient module declaration into an error), no longer auto-loads every `@types` package when `types` is unset the way TypeScript 5 did (the `"*"` wildcard restores that last default), and flips `esModuleInterop` from `false` to `true` (so an `import * as x from '<cjs>'` binds a non-callable namespace object and a call or `new` on that import fails at runtime). Pinning all four preserves the pre-TypeScript 6 behavior. Because `esModuleInterop: false` is itself a TypeScript 6 deprecated value, this pin runs before the `ignoreDeprecations` edit above, so the added `false` is silenced in the same run.
+- Adds `"ignoreDeprecations": "6.0"` to every `tsconfig.json` (the exact file name jest and ts-node auto-resolve), even one that carries no deprecated option of its own. Those loaders compile config files such as `jest.config.ts`, and ts-node injects a default `target: es5` when the config leaves it unset. TypeScript 6 rejects `es5` as a deprecated value, so the flag keeps that load working. It is inert wherever nothing is actually deprecated.
 
-Files that use `extends` inherit these settings from their chain root and are left untouched, and pure solution-style tsconfigs (`"files": []` with no `include`) are skipped. The migration only runs when the workspace is on TypeScript 6.
+Files that use `extends` inherit the pinned settings from their chain root, so the pins are not repeated on them, and pure solution-style tsconfigs (`"files": []` with no `include`) receive no pins either, though a solution-style `tsconfig.json` still gets the config-load flag. The migration only runs when the workspace is on TypeScript 6.
 
 #### Sample Code Changes
 
@@ -23,15 +24,17 @@ Files that use `extends` inherit these settings from their chain root and are le
 
 ##### After
 
-```json title="tsconfig.json" {6-8}
+```json title="tsconfig.json" {6-10}
 {
   "compilerOptions": {
     "target": "es5",
     "module": "esnext",
     "moduleResolution": "bundler",
-    "ignoreDeprecations": "6.0",
     "strict": false,
-    "noUncheckedSideEffectImports": false
+    "noUncheckedSideEffectImports": false,
+    "types": ["*"],
+    "esModuleInterop": false,
+    "ignoreDeprecations": "6.0"
   }
 }
 ```

package/dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6.d.ts

@@ -0,0 +1,26 @@
+import { type Tree } from '@nx/devkit';
+/**
+ * TypeScript 6.0 changed the implicit `rootDir`. Before 6.0 an unset `rootDir`
+ * was inferred as the common directory of a program's non-declaration input
+ * files; 6.0 defaults it to the tsconfig's own directory instead. A program
+ * whose files resolve outside that directory (most commonly a spec/e2e tsconfig
+ * importing another project's source through a `paths` alias) then hard-fails
+ * with TS5011 or TS6059.
+ *
+ * For every project `tsconfig*.json` that lacks an explicit `rootDir`, this pins
+ * `rootDir` to exactly the directory TypeScript 5 would have inferred, so both
+ * compilation and emit layout are unchanged under 6.0. The value is computed by
+ * the compiler itself: a throwaway program built with `configFilePath` cleared
+ * takes the file-derived branch of `getCommonSourceDirectory`, so it matches
+ * `tsc` exactly, including project-reference redirects. Configs already at the
+ * 6.0 default are left untouched: their inferred directory equals the tsconfig
+ * directory, or they are composite (which defaulted there before 6.0 too).
+ *
+ * Each config is written on its own; nothing is written to a shared `extends`
+ * base, so a config never inherits a `rootDir` computed for a sibling. The one
+ * case that needs care is a config that both needs a `rootDir` and is itself an
+ * `extends` base: its own-directory children would inherit the new value and
+ * shift their emit layout, so each such child is pinned to its own directory to
+ * block it. Runs only on TypeScript 6 workspaces (gated by `requires`).
+ */
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const node_path_1 = require("node:path");
+const jsonc_parser_1 = require("jsonc-parser");
+const ensure_typescript_1 = require("../../utils/typescript/ensure-typescript");
+const FORMATTING_OPTIONS = {
+    formattingOptions: { keepLines: true, insertSpaces: true, tabSize: 2 },
+};
+let tsModule;
+/**
+ * TypeScript 6.0 changed the implicit `rootDir`. Before 6.0 an unset `rootDir`
+ * was inferred as the common directory of a program's non-declaration input
+ * files; 6.0 defaults it to the tsconfig's own directory instead. A program
+ * whose files resolve outside that directory (most commonly a spec/e2e tsconfig
+ * importing another project's source through a `paths` alias) then hard-fails
+ * with TS5011 or TS6059.
+ *
+ * For every project `tsconfig*.json` that lacks an explicit `rootDir`, this pins
+ * `rootDir` to exactly the directory TypeScript 5 would have inferred, so both
+ * compilation and emit layout are unchanged under 6.0. The value is computed by
+ * the compiler itself: a throwaway program built with `configFilePath` cleared
+ * takes the file-derived branch of `getCommonSourceDirectory`, so it matches
+ * `tsc` exactly, including project-reference redirects. Configs already at the
+ * 6.0 default are left untouched: their inferred directory equals the tsconfig
+ * directory, or they are composite (which defaulted there before 6.0 too).
+ *
+ * Each config is written on its own; nothing is written to a shared `extends`
+ * base, so a config never inherits a `rootDir` computed for a sibling. The one
+ * case that needs care is a config that both needs a `rootDir` and is itself an
+ * `extends` base: its own-directory children would inherit the new value and
+ * shift their emit layout, so each such child is pinned to its own directory to
+ * block it. Runs only on TypeScript 6 workspaces (gated by `requires`).
+ */
+async function default_1(tree) {
+    tsModule ??= (0, ensure_typescript_1.ensureTypescript)();
+    const ts = tsModule;
+    const parseConfigHost = {
+        ...ts.sys,
+        onUnRecoverableConfigFileDiagnostic: () => { },
+    };
+    const relPaths = collectProjectTsconfigs(tree);
+    // Phase 1: analyze every candidate against the on-disk configs.
+    const candidates = relPaths.map((relPath) => {
+        const absPath = toPosix((0, node_path_1.join)(tree.root, relPath));
+        return {
+            relPath,
+            dirAbs: toPosix((0, node_path_1.dirname)(absPath)),
+            analysis: analyze(ts, absPath, parseConfigHost),
+        };
+    });
+    // Phase 2: pin each config that needs a `rootDir` on its own.
+    let changed = 0;
+    for (const c of candidates) {
+        if (c.analysis.kind === 'write') {
+            const rootDir = toRelativeRootDir(c.dirAbs, c.analysis.dirAbs);
+            if (setRootDir(tree, c.relPath, rootDir)) {
+                changed++;
+            }
+        }
+    }
+    // Phase 3: shield own-dir configs that now inherit a pinned `rootDir` from a
+    // base. Re-parse each from the tree (so Phase 2's writes are visible); when
+    // TypeScript reports an inherited `rootDir` where there was none, pin the
+    // config to its own directory so its emit layout does not shift. Repeat until
+    // stable, since shielding one config can turn it into a base for another. The
+    // tree-backed host lets TypeScript resolve `extends`; the `readDirectory`
+    // no-op skips the unused file scan.
+    const readFile = (filePath) => tree.read(filePath, 'utf-8') ?? undefined;
+    const treeParseHost = {
+        ...ts.sys,
+        readFile,
+        readDirectory: () => [],
+    };
+    const shielded = new Set();
+    let added = true;
+    while (added) {
+        added = false;
+        for (const c of candidates) {
+            if (c.analysis.kind !== 'own-dir' || shielded.has(c.relPath)) {
+                continue;
+            }
+            if (inheritsRootDir(ts, treeParseHost, readFile, c.relPath)) {
+                if (setRootDir(tree, c.relPath, '.')) {
+                    changed++;
+                }
+                shielded.add(c.relPath);
+                added = true;
+            }
+        }
+    }
+    if (changed > 0) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+function analyze(ts, absPath, parseConfigHost) {
+    const parsed = ts.getParsedCommandLineOfConfigFile(absPath, undefined, parseConfigHost);
+    if (!parsed) {
+        return { kind: 'inert' };
+    }
+    const { options, fileNames, projectReferences } = parsed;
+    if (options.rootDir != null) {
+        return { kind: 'has-rootDir' };
+    }
+    if (!setsEmitGate(options) || fileNames.length === 0) {
+        return { kind: 'inert' };
+    }
+    // Composite already defaults `rootDir` to the tsconfig's own directory in both
+    // 5.x and 6.0, so the 6.0 change leaves it alone. Treat it as own-dir: never
+    // pin a file-derived value, and shield it from a `rootDir` this migration pins
+    // on an `extends` base.
+    if (options.composite) {
+        return { kind: 'own-dir' };
+    }
+    const commonDir = computeCommonSourceDirectory(ts, fileNames, options, projectReferences);
+    if (!commonDir) {
+        return { kind: 'inert' };
+    }
+    if (equalPaths(ts, commonDir, (0, node_path_1.dirname)(absPath))) {
+        return { kind: 'own-dir' };
+    }
+    return { kind: 'write', dirAbs: toPosix(commonDir).replace(/\/+$/, '') };
+}
+// True when TypeScript resolves an inherited `rootDir` for the config. An own-dir
+// config sets none of its own, so any `rootDir` reported here comes from a base
+// this migration just pinned, and inheriting it would shift the config's emit
+// layout.
+function inheritsRootDir(ts, parseHost, readFile, relPath) {
+    const config = ts.readConfigFile(relPath, readFile).config;
+    if (!config) {
+        return false;
+    }
+    const { options } = ts.parseJsonConfigFileContent(config, parseHost, (0, node_path_1.dirname)(relPath));
+    return options.rootDir != null;
+}
+// Any of these makes TypeScript run the source-file containment / common-source
+// computation that emits TS5011 / TS6059 when `rootDir` is absent.
+function setsEmitGate(o) {
+    return !!(o.outDir ||
+        o.outFile ||
+        o.sourceRoot ||
+        o.mapRoot ||
+        (o.declaration && o.declarationDir));
+}
+function computeCommonSourceDirectory(ts, rootNames, parsedOptions, projectReferences) {
+    // Clearing `configFilePath` makes `getCommonSourceDirectory` take the
+    // file-derived branch (the pre-6.0 inference) instead of returning the
+    // tsconfig's own directory. `noLib` skips lib.d.ts (declarations, irrelevant
+    // to the calc). `projectReferences` preserves reference-redirect semantics, so
+    // a source file provided by a referenced project is excluded via its `.d.ts`.
+    const options = {
+        ...parsedOptions,
+        noLib: true,
+        configFilePath: undefined,
+    };
+    // A fresh host per program so each config resolves on its own, with no parse or
+    // module-resolution state shared across configs. Letting the program resolve
+    // modules itself (no custom `resolveModuleNameLiterals`) keeps resolution
+    // mode-aware under node16/nodenext/bundler, matching tsc.
+    const host = ts.createCompilerHost(options, /* setParentNodes */ false);
+    const program = ts.createProgram({
+        rootNames,
+        options,
+        host,
+        projectReferences,
+    });
+    // `getCommonSourceDirectory` is a real Program method but is absent from the
+    // public `Program` type, so widen it here.
+    const commonSourceDirectory = program.getCommonSourceDirectory();
+    return commonSourceDirectory || undefined;
+}
+function collectProjectTsconfigs(tree) {
+    const projectRoots = [...(0, devkit_1.getProjects)(tree).values()].map((p) => p.root === '.' ? '' : p.root);
+    const tsconfigs = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        const name = (0, node_path_1.basename)(filePath);
+        if (!name.startsWith('tsconfig') || !name.endsWith('.json')) {
+            return;
+        }
+        const normalized = toPosix(filePath);
+        // Only touch tsconfigs owned by a project; never a workspace-root base
+        // whose (unknown) extenders we would silently affect.
+        if (projectRoots.some((root) => root === '' || normalized.startsWith(`${root}/`))) {
+            tsconfigs.push(filePath);
+        }
+    });
+    return tsconfigs;
+}
+function setRootDir(tree, tsconfigPath, rootDir) {
+    const contents = tree.read(tsconfigPath, 'utf-8');
+    if (!contents) {
+        return false;
+    }
+    const edits = (0, jsonc_parser_1.modify)(contents, ['compilerOptions', 'rootDir'], rootDir, FORMATTING_OPTIONS);
+    if (edits.length === 0) {
+        return false;
+    }
+    tree.write(tsconfigPath, (0, jsonc_parser_1.applyEdits)(contents, edits));
+    return true;
+}
+function toRelativeRootDir(tsconfigDir, commonDir) {
+    const rel = node_path_1.posix.relative(toPosix(tsconfigDir), toPosix(commonDir));
+    return rel === '' ? '.' : rel;
+}
+function equalPaths(ts, a, b) {
+    const normalize = (p) => {
+        const stripped = toPosix(p).replace(/\/+$/, '');
+        return ts.sys.useCaseSensitiveFileNames ? stripped : stripped.toLowerCase();
+    };
+    return normalize(a) === normalize(b);
+}
+function toPosix(p) {
+    return p.split('\\').join('/');
+}

package/dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6.md

@@ -0,0 +1,36 @@
+#### Pin the Inferred `rootDir` for TypeScript 6
+
+Before TypeScript 6, a tsconfig that did not set `rootDir` had it inferred as the common directory of the program's non-declaration input files. TypeScript 6 changed that default to the tsconfig's own directory. A program whose files resolve outside that directory (most commonly a spec or e2e tsconfig that imports another project's source through a `paths` alias) now hard-fails with `TS5011` or `TS6059` because a file falls outside the assumed root.
+
+For every project `tsconfig*.json` that does not already set `rootDir` (directly or through `extends`), this migration pins `rootDir` to exactly the directory TypeScript 5 would have inferred, so both compilation and emit layout stay the same under TypeScript 6. The value is computed by the TypeScript compiler itself, so it matches `tsc` exactly, including project-reference redirects. Configs that cannot hit the error are skipped: ones without an output option (`outDir`, `outFile`, `sourceRoot`, `mapRoot`, or `declaration` + `declarationDir`), ones with no input files, composite projects (whose `rootDir` already defaulted to the tsconfig directory before TypeScript 6), and ones whose inferred directory already equals the tsconfig directory. The migration only runs when the workspace is on TypeScript 6.
+
+Each config is updated on its own; the migration never writes `rootDir` to a shared `extends` base, so a config never inherits a value computed for a sibling. The one case that needs care is a config that both needs a `rootDir` and is itself an `extends` base: its self-contained children would inherit the new value and emit to the wrong place, so each such child is pinned to its own directory to keep its layout. This includes a composite child, whose own-directory default would otherwise be overridden by the inherited value.
+
+#### Sample Code Changes
+
+##### Before
+
+A `libs/products/e2e/tsconfig.json` whose specs import a shared library's source:
+
+```json title="libs/products/e2e/tsconfig.json"
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc"
+  },
+  "include": ["src/**/*.ts"]
+}
+```
+
+##### After
+
+```json title="libs/products/e2e/tsconfig.json" {4}
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "../../..",
+    "outDir": "../../../dist/out-tsc"
+  },
+  "include": ["src/**/*.ts"]
+}
+```

package/dist/src/utils/buildable-libs-utils.js

@@ -282,7 +282,15 @@ function updatePaths(dependencies, paths) {
                     const { root } = dep.node.data;
                     // Update nested mappings to point to the dependency's output paths
                     mappedPaths = mappedPaths.concat(paths[path].flatMap((p) => dep.outputs.flatMap((output) => {
-                        const basePath = p.replace(root, output);
+                        // Re-map the root prefix to the output. Match root only as a
+                        // leading segment (after an optional `./`) so a root that
+                        // also appears later in the value (e.g. output `dist/libs/base`
+                        // for root `base`) isn't doubled.
+                        const dotPrefix = p.startsWith('./') ? './' : '';
+                        const value = dotPrefix ? p.slice(2) : p;
+                        const basePath = value === root || value.startsWith(`${root}/`)
+                            ? `${dotPrefix}${output}${value.slice(root.length)}`
+                            : p;
                         return [
                             // extension-less path to support compiled output
                             basePath.replace(new RegExp(`${(0, path_1.extname)(basePath)}$`, 'gi'), ''),

package/dist/src/utils/prettier.js

@@ -5,14 +5,23 @@ exports.generatePrettierSetup = generatePrettierSetup;
 exports.resolvePrettierConfigPath = resolvePrettierConfigPath;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("./versions");
-async function resolveUserExistingPrettierConfig() {
-    let prettier;
+// Prettier v3 (ESM) exposes its API as named exports; v2 (CJS) exposes it under
+// `.default` when loaded via `import()`. Return whichever carries the API, or
+// null if prettier isn't installed.
+async function importPrettier() {
     try {
-        prettier = await import('prettier');
+        const imported = await import('prettier');
+        return (imported.resolveConfig ? imported : imported.default);
     }
     catch {
         return null;
     }
+}
+async function resolveUserExistingPrettierConfig() {
+    const prettier = await importPrettier();
+    if (!prettier) {
+        return null;
+    }
     try {
         const filepath = await prettier.resolveConfigFile();
         if (!filepath) {
@@ -76,18 +85,13 @@ function generatePrettierSetup(tree, options) {
         : (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { prettier: versions_1.prettierVersion });
 }
 async function resolvePrettierConfigPath(tree) {
-    let prettier;
-    try {
-        prettier = await import('prettier');
-    }
-    catch {
+    const prettier = await importPrettier();
+    if (!prettier) {
         return null;
     }
-    if (prettier) {
-        const filePath = await prettier.resolveConfigFile();
-        if (filePath) {
-            return filePath;
-        }
+    const configFilePath = await prettier.resolveConfigFile();
+    if (configFilePath) {
+        return configFilePath;
     }
     if (!tree) {
         return null;

package/dist/src/utils/swc/compile-swc.js

@@ -44,7 +44,10 @@ function getTypeCheckOptions(normalizedOptions) {
     };
     if (watch) {
         typeCheckOptions.incremental = true;
-        typeCheckOptions.cacheDir = devkit_1.cacheDir;
+        // Scope the incremental .tsbuildinfo per project (in its own subdir, not
+        // alongside Nx's cache files) so concurrent watch type-checks don't collide
+        // on a single file.
+        typeCheckOptions.cacheDir = (0, node_path_1.join)(devkit_1.cacheDir, 'swc', projectRoot);
     }
     if (normalizedOptions.isTsSolutionSetup && normalizedOptions.skipTypeCheck) {
         typeCheckOptions.ignoreDiagnostics = true;

package/dist/src/utils/typescript/run-type-check.js

@@ -43,6 +43,10 @@ async function runTypeCheck(options) {
             options: {
                 ...compilerOptions,
                 incremental: true,
+                // Set after the spread so it overrides any user-set tsBuildInfoFile.
+                // This is a dedicated type-check program with Nx-injected options that
+                // differ from the real build, so its build info must not share a file
+                // with the build, or it corrupts the build's incremental cache.
                 tsBuildInfoFile: path.join(cacheDir, '.tsbuildinfo'),
             },
         });

package/migrations.json

@@ -30,13 +30,22 @@
       "documentation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md"
     },
     "23-1-0-add-ignore-deprecations-for-ts6": {
-      "version": "23.1.0-beta.0",
-      "description": "Adds `\"ignoreDeprecations\": \"6.0\"` to tsconfig files whose compilerOptions (or ts-node.compilerOptions) directly carry a TypeScript 6 deprecated option value (e.g. moduleResolution node/node10/classic, baseUrl, target es5, esModuleInterop false, outFile, module amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports false, downlevelIteration set). Also pins `\"strict\": false` and `\"noUncheckedSideEffectImports\": false` in chain-root tsconfigs (no \"extends\") that lack each key, preserving pre-TS6 behavior where their defaults were less strict.",
+      "version": "23.1.0-beta.8",
+      "description": "Adds `\"ignoreDeprecations\": \"6.0\"` to tsconfig files whose compilerOptions (or ts-node.compilerOptions) carry a TypeScript 6 deprecated option value, set directly or inherited through `extends` including from a base this migration does not edit (e.g. moduleResolution node/node10/classic, baseUrl, target es5, esModuleInterop false, outFile, module amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports false, downlevelIteration set). Also pins `\"strict\": false`, `\"noUncheckedSideEffectImports\": false`, `\"types\": [\"*\"]`, and `\"esModuleInterop\": false` in chain-root tsconfigs (no \"extends\") that lack each key, preserving pre-TS6 behavior where these defaults changed; `esModuleInterop` false is itself deprecated (removed in TS7) so it also receives `ignoreDeprecations`, deferring the interop change to the TS7 migration. Also adds `ignoreDeprecations` to every `tsconfig.json` (the exact name jest/ts-node auto-resolve when compiling a config file; ts-node injects a deprecated default `target: es5` there, so the load hits a TS6 error even on a clean config), even one with no deprecated value of its own; a stale local `ignoreDeprecations` (e.g. `5.0`) that would otherwise override the inherited flag is upgraded.",
       "requires": {
         "typescript": ">=6.0.0"
       },
       "factory": "./dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6",
       "documentation": "./dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.md"
+    },
+    "23-1-0-set-tsconfig-root-dir-for-ts6": {
+      "version": "23.1.0-beta.8",
+      "description": "Sets an explicit `rootDir` on project `tsconfig*.json` files that lack one, pinned to the source directory TypeScript 5 inferred implicitly, so programs whose input files span more than one directory (for example a spec tsconfig importing another project's source through a `paths` alias) keep compiling under TypeScript 6, which otherwise hard-fails with TS5011 or TS6059. The value is computed by the compiler, so emit layout is unchanged. Each config is written on its own; the migration never writes to a shared `extends` base, so a config never inherits a value computed for a sibling. Composite projects are not given an inferred `rootDir`, since it already defaulted to the tsconfig directory before TypeScript 6; a composite that extends a base receiving a pinned `rootDir` is itself pinned to its own directory to preserve that default.",
+      "requires": {
+        "typescript": ">=6.0.0"
+      },
+      "factory": "./dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6",
+      "documentation": "./dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6.md"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.1.0-pr.36127.8b9019b",
+  "version": "23.1.0-rc.0",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -144,11 +144,11 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/workspace": "23.1.0-pr.36127.8b9019b",
-    "@nx/devkit": "23.1.0-pr.36127.8b9019b"
+    "@nx/workspace": "23.1.0-rc.0",
+    "@nx/devkit": "23.1.0-rc.0"
   },
   "devDependencies": {
-    "nx": "23.1.0-pr.36127.8b9019b"
+    "nx": "23.1.0-rc.0"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",