nx 23.2.0-beta.7 → 23.2.0-beta.9

package/dist/src/migrations/update-21-0-0/release-version-config-changes.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
 const node_path_1 = require("node:path");
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const json_1 = require("../../generators/utils/json");
 const nx_json_1 = require("../../generators/utils/nx-json");
 const project_configuration_1 = require("../../generators/utils/project-configuration");
@@ -97,5 +97,5 @@ async function update(tree) {
         }
     }
     (0, nx_json_1.updateNxJson)(tree, nxJson);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-21-0-0/remove-custom-tasks-runner.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const nx_json_1 = require("../../generators/utils/nx-json");
 function isCustomRunnerPath(modulePath) {
     return !['nx-cloud', '@nrwl/nx-cloud', 'nx/tasks-runners/default'].includes(modulePath);
@@ -33,6 +33,6 @@ async function update(tree) {
         delete nxJson.tasksRunnerOptions;
     }
     (0, nx_json_1.updateNxJson)(tree, nxJson);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
     return nextSteps;
 }

package/dist/src/migrations/update-21-0-0/remove-legacy-cache.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const nx_json_1 = require("../../generators/utils/nx-json");
 async function update(tree) {
     const nxJson = (0, nx_json_1.readNxJson)(tree);
@@ -13,5 +13,5 @@ async function update(tree) {
         delete nxJson.useLegacyCache;
     }
     (0, nx_json_1.updateNxJson)(tree, nxJson);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-22-0-0/consolidate-release-tag-config.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
 const node_path_1 = require("node:path");
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const json_1 = require("../../generators/utils/json");
 const nx_json_1 = require("../../generators/utils/nx-json");
 const project_configuration_1 = require("../../generators/utils/project-configuration");
@@ -96,5 +96,5 @@ async function update(tree) {
         }
     }
     (0, nx_json_1.updateNxJson)(tree, nxJson);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-22-0-0/release-version-config-changes.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
 const node_path_1 = require("node:path");
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const json_1 = require("../../generators/utils/json");
 const nx_json_1 = require("../../generators/utils/nx-json");
 const project_configuration_1 = require("../../generators/utils/project-configuration");
@@ -97,5 +97,5 @@ async function update(tree) {
         }
     }
     (0, nx_json_1.updateNxJson)(tree, nxJson);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-22-2-0/add-self-healing-to-gitignore.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = addSelfHealingToGitignore;
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const ignore_1 = require("../../utils/ignore");
 async function addSelfHealingToGitignore(tree) {
     if (!tree.exists('.gitignore')) {
@@ -15,5 +15,5 @@ async function addSelfHealingToGitignore(tree) {
     if (tree.exists('.prettierignore')) {
         (0, ignore_1.addEntryToGitIgnore)(tree, '.prettierignore', '.nx/self-healing');
     }
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-22-6-0/add-claude-settings-local-to-git-ignore.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = addClaudeSettingsLocalToGitIgnore;
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const ignore_1 = require("../../utils/ignore");
 async function addClaudeSettingsLocalToGitIgnore(tree) {
     if (!tree.exists('.gitignore')) {
@@ -12,5 +12,5 @@ async function addClaudeSettingsLocalToGitIgnore(tree) {
         return;
     }
     (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.claude/settings.local.json');
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-22-6-0/add-claude-worktrees-to-git-ignore.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = addClaudeWorktreesToGitIgnore;
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const ignore_1 = require("../../utils/ignore");
 async function addClaudeWorktreesToGitIgnore(tree) {
     if (!tree.exists('.gitignore')) {
@@ -12,5 +12,5 @@ async function addClaudeWorktreesToGitIgnore(tree) {
         return;
     }
     (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.claude/worktrees');
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-22-7-0/add-polygraph-to-git-ignore.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = addPolygraphToGitIgnore;
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const ignore_1 = require("../../utils/ignore");
 async function addPolygraphToGitIgnore(tree) {
     if (!tree.exists('.gitignore')) {
@@ -12,5 +12,5 @@ async function addPolygraphToGitIgnore(tree) {
         return;
     }
     (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.nx/polygraph');
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-23-0-0/add-migrate-runs-to-git-ignore.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = addMigrateRunsToGitIgnore;
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
 const ignore_1 = require("../../utils/ignore");
 async function addMigrateRunsToGitIgnore(tree) {
     if (!tree.exists('.gitignore')) {
@@ -12,5 +12,5 @@ async function addMigrateRunsToGitIgnore(tree) {
         return;
     }
     (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.nx/migrate-runs');
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.d.ts

@@ -0,0 +1,12 @@
+import { Tree } from '../../generators/tree';
+/**
+ * Target defaults resolve to a single key rather than merging, so an executor
+ * key hides the target name key entirely. Before Nx 23 a hidden `cache: true`
+ * still took effect, because cacheability was also derived from target *names*
+ * via `cacheableOperations`; Nx 23 removed that derivation and those targets
+ * silently stopped being cacheable.
+ *
+ * Write the intent into the executor key so it no longer depends on the
+ * deprecated fallback that restores the old behavior at run time.
+ */
+export default function update(tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const executor_utils_1 = require("../../command-line/run/executor-utils");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
+const json_1 = require("../../generators/utils/json");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const path_1 = require("../../utils/path");
+// TODO(v24): remove this migration alongside the runtime fallback it exists to
+// retire (`isLegacyCachedTarget` in `target-normalization.ts`), along with its
+// registration in `packages/nx/migrations.json`.
+/**
+ * Target defaults resolve to a single key rather than merging, so an executor
+ * key hides the target name key entirely. Before Nx 23 a hidden `cache: true`
+ * still took effect, because cacheability was also derived from target *names*
+ * via `cacheableOperations`; Nx 23 removed that derivation and those targets
+ * silently stopped being cacheable.
+ *
+ * Write the intent into the executor key so it no longer depends on the
+ * deprecated fallback that restores the old behavior at run time.
+ */
+async function update(tree) {
+    const nxJson = (0, project_configuration_1.readNxJson)(tree);
+    const targetDefaults = nxJson?.targetDefaults;
+    if (!targetDefaults) {
+        return;
+    }
+    const projects = (0, project_configuration_1.getProjects)(tree);
+    const projectsMap = {};
+    // `cache` on an executor key reaches every target that resolves through it,
+    // not just the one whose target name key enables caching. Collect them all
+    // per key so the decision below can be made for the key as a whole. The
+    // collection is a list rather than a map keyed by target name: two projects
+    // routinely declare the same target name through the same executor, and only
+    // one of them may be continuous.
+    const targetsByExecutorKey = new Map();
+    const collect = (targetName, target) => {
+        // `hasOwnProperty` rather than a lookup: an executor named `__proto__` or
+        // `constructor` resolves through the prototype chain to a truthy object, so
+        // a plain lookup would collect the target and stamp `Object.prototype`.
+        if (!target?.executor ||
+            !Object.prototype.hasOwnProperty.call(targetDefaults, target.executor)) {
+            return;
+        }
+        const targets = targetsByExecutorKey.get(target.executor) ?? [];
+        targets.push([targetName, target]);
+        targetsByExecutorKey.set(target.executor, targets);
+    };
+    for (const [projectName, project] of projects) {
+        projectsMap[projectName] = project;
+        for (const [targetName, target] of Object.entries(project.targets ?? {})) {
+            collect(targetName, target);
+        }
+        for (const [targetName, target] of Object.entries(packageJsonTargets(tree, project.root))) {
+            collect(targetName, target);
+        }
+    }
+    let changed = false;
+    for (const [key, targets] of targetsByExecutorKey) {
+        if (!canEnableCache(targetDefaults, key, targets, tree.root, projectsMap)) {
+            continue;
+        }
+        catchAllConfig(targetDefaults[key]).cache = true;
+        changed = true;
+    }
+    if (!changed) {
+        return;
+    }
+    (0, project_configuration_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
+}
+/**
+ * Whether `cache: true` can be written onto `key` without changing behavior for
+ * any target that resolves through it.
+ *
+ * The executor key outranks every target name key, so stamping it caches all of
+ * `targets` — including any that is continuous, which makes `nx.json` fail graph
+ * construction outright. The key is only safe when every target through it
+ * independently wants caching and none of them can be continuous. Anything else
+ * is left to the runtime fallback, which decides per target after normalization
+ * and can therefore see continuity this migration cannot.
+ */
+function canEnableCache(targetDefaults, key, targets, workspaceRoot, projectsMap) {
+    // Targets written with `command` are rewritten to `nx:run-commands` and
+    // `package.json` scripts to `nx:run-script` before key selection, so neither
+    // names the key it resolves through. Plugins also infer continuous targets
+    // (`watch-deps`, dev servers) into projects whose config never mentions them.
+    // The target list here can never be trusted to be complete for these keys.
+    if (key === 'nx:run-commands' || key === 'nx:run-script') {
+        return false;
+    }
+    // Already decided; never override the user's value. A filtered entry counts
+    // as decided because its value can't be evaluated without project context.
+    if (declaresAnyCache(targetDefaults[key])) {
+        return false;
+    }
+    // `continuous` is a valid field on a target default, and this key applies it
+    // to every target that resolves through it. Adding `cache` would make each of
+    // them both cacheable and continuous, which fails graph construction — so no
+    // target list can make this key safe.
+    if (declaresAnyContinuous(targetDefaults[key])) {
+        return false;
+    }
+    // Only an unfiltered entry can be amended. Appending a catch-all to an
+    // all-filtered key would make it match targets that previously fell through
+    // to the target name key, silently dropping that key's `dependsOn`/`inputs`.
+    if (!catchAllConfig(targetDefaults[key])) {
+        return false;
+    }
+    // Continuity declared by the executor's schema is resolved at graph
+    // construction for every target through this key, so one lookup covers them
+    // all. For what an executor that cannot be resolved here costs, see
+    // {@link executorDeclaresContinuous}.
+    if (executorDeclaresContinuous(key, workspaceRoot, projectsMap)) {
+        return false;
+    }
+    for (const [targetName, target] of targets) {
+        if (!declaresCacheTrue(targetDefaults[targetName])) {
+            return false;
+        }
+        if (target.continuous || isLongRunningTargetName(targetName)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the target name key declares `cache: true` on an entry that always
+ * applies. Mirrors `declaresCacheTrue` in `target-normalization.ts`: a filtered
+ * entry declaring `cache` makes the value unknowable without project context,
+ * so nothing is claimed. Among unfiltered entries the last wins.
+ */
+function declaresCacheTrue(value) {
+    if (!value) {
+        return false;
+    }
+    let declared;
+    for (const entry of configEntries(value)) {
+        if (entry.cache === undefined)
+            continue;
+        if (entry.filter)
+            return false;
+        declared = entry.cache;
+    }
+    return declared === true;
+}
+/**
+ * Whether any entry declares `cache`, filtered or not — i.e. whether the value
+ * is already decided and must be left alone. Deliberately broader than
+ * {@link declaresCacheTrue}: a filtered `cache` blocks here rather than being
+ * read past, so the two never disagree about a filtered entry.
+ */
+function declaresAnyCache(value) {
+    if (!value) {
+        return false;
+    }
+    return configEntries(value).some((entry) => entry.cache !== undefined);
+}
+/**
+ * Whether any entry declares `continuous: true`. Filtered entries count: which
+ * projects the filter matches is unknowable here, and the only case that
+ * matters is the one where it matches.
+ */
+function declaresAnyContinuous(value) {
+    if (!value) {
+        return false;
+    }
+    return configEntries(value).some((entry) => entry.continuous === true);
+}
+/**
+ * The config blocks of a `targetDefaults` value. Entries that are not config
+ * objects are dropped rather than inspected: `nx.json` is hand-edited, and a
+ * `null` or scalar entry would otherwise throw while reading `.cache` off it.
+ */
+function configEntries(value) {
+    const entries = Array.isArray(value) ? value : [value];
+    return entries.filter((entry) => !!entry && typeof entry === 'object');
+}
+/**
+ * The targets a project's `package.json` contributes to the graph.
+ *
+ * {@link getProjects} builds a root's configuration from its `project.json`
+ * alone whenever one exists, but the package.json plugin still creates the
+ * sibling `package.json`'s targets — it accepts any `package.json` that is
+ * either in the package manager workspaces or next to a `project.json`
+ * (`plugins/package-json/create-nodes.ts`). Those targets resolve through the
+ * same executor keys, so they belong in this decision.
+ *
+ * Targets derived from `scripts` are still not covered; they resolve through
+ * `nx:run-script`, which is never stamped for exactly that reason.
+ */
+function packageJsonTargets(tree, projectRoot) {
+    const packageJsonPath = (0, path_1.joinPathFragments)(projectRoot, 'package.json');
+    if (!tree.exists(packageJsonPath)) {
+        return {};
+    }
+    // A parse failure is left to throw: `readJson` names the offending file,
+    // which is the one thing a user can act on. Shapes that parse but aren't the
+    // one this reads contribute no targets rather than crashing the run.
+    const targets = (0, json_1.readJson)(tree, packageJsonPath)?.nx?.targets;
+    if (!targets || typeof targets !== 'object' || Array.isArray(targets)) {
+        return {};
+    }
+    return targets;
+}
+/**
+ * The unfiltered config block of a `targetDefaults` value, or undefined when the
+ * array form carries only filtered entries and when the value is not a config
+ * object at all. Never creates one — see {@link canEnableCache}.
+ */
+function catchAllConfig(value) {
+    // The filter check applies to both spellings: the object and single-element
+    // array forms of the same config have to reach the same verdict.
+    return configEntries(value).find((entry) => entry.filter === undefined);
+}
+/**
+ * Whether the executor's schema marks its targets continuous, resolved through
+ * the same `getExecutorInformation` call `normalizeTarget` makes at graph
+ * construction, so the two cannot drift on what continuous means.
+ *
+ * An executor that cannot be resolved is read as not continuous. That is the
+ * same answer `normalizeTarget` gives, but not the same trade: its lookup is
+ * repeated on every graph construction, so a failure there corrects itself,
+ * whereas this one decides a permanent edit to `nx.json`. An executor that is
+ * unresolvable while the migration runs and resolvable afterwards therefore
+ * keeps its stamped `cache` while the runtime starts marking its targets
+ * continuous — which `normalizeTargets` rejects with a `WorkspaceValidityError`,
+ * failing graph construction until `nx.json` is edited by hand.
+ */
+function executorDeclaresContinuous(executor, workspaceRoot, projectsMap) {
+    try {
+        const [nodeModule, name] = (0, executor_utils_1.parseExecutor)(executor);
+        const { schema } = (0, executor_utils_1.getExecutorInformation)(nodeModule, name, workspaceRoot, projectsMap);
+        return !!schema.continuous;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Target names the pre-23 `longRunningTask` guard excluded from caching.
+ * Mirrors `isLongRunningTarget` in `target-normalization.ts`.
+ */
+function isLongRunningTargetName(targetName) {
+    return (targetName.endsWith(':watch') ||
+        targetName.endsWith('-watch') ||
+        targetName === 'serve' ||
+        targetName === 'dev' ||
+        targetName === 'start');
+}

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.md

@@ -0,0 +1,50 @@
+#### Set cache on executor-based target defaults
+
+Maintains compatibility with how cacheability was resolved before Nx 23.
+
+Target defaults resolve to a single key rather than merging them. When a target matches both a target name key and an executor key, the executor key is the one that applies, and the target name key is not read at all. Earlier versions of Nx also derived cacheability from target names, so `"cache": true` on the target name key still took effect even when an executor key applied. Nx 23 reads cacheability from the resolved target only.
+
+This migration copies `cache` onto each executor key that applies to a target whose target name key enables it, so those targets remain cacheable.
+
+An executor key applies to every target that resolves through it, so the migration updates a key only when it can establish that caching is right for all of them. It leaves the key unchanged when the key already declares `cache`, when it declares `continuous: true`, when every entry on the key is filtered so none of them always applies, when a target through it is continuous or is a long-running target such as `serve`, `dev`, or `start`, when the executor's own schema marks its targets continuous, or when a target through it has no target name key enabling `cache`. It never updates the `nx:run-commands` or `nx:run-script` keys, because targets written with `command` and targets derived from `package.json` scripts resolve through those keys without naming them.
+
+Where the migration makes no change, Nx still decides at run time, per target rather than per key: a target whose target name key enables `cache`, and whose resolved configuration still leaves `cache` undefined, gets it back and is reported as a deprecated fallback. Because that test is applied to the resolved target rather than to the key, it also covers the cases where a key looks decided but is not for this project — an executor key whose entries are all filtered, or whose only `cache` declaration is filtered out here. It equally covers the targets left behind because a sibling target through the same key does not opt in, and the targets reaching the `nx:run-commands` and `nx:run-script` keys. Three cases get no fallback and no warning. A continuous or long-running target, because caching it is invalid. A target whose resolved configuration already sets `cache`. And a target whose target name key was discarded as incompatible, because its entry named an executor the target does not use — before Nx 23 that target was cacheable, since cacheability was matched on target name alone and the entry's `executor` was never read. Restoring it here would mean setting `cache` with no executor key to point the user at and no migration able to retire the behavior, so it is deliberately left alone. Set `cache` on those targets directly.
+
+Targets are read from each project's `project.json` and from the `nx.targets` block of its `package.json`. Targets inferred by a plugin, and targets derived from `package.json` scripts, are not visible to the migration — the latter is why the `nx:run-script` key is never updated. A key that looks safe here may still serve an inferred target. Set `cache` on the executor key by hand only after checking that no target reaching it is continuous; Nx rejects a target that is both cacheable and continuous. Nx names both keys in a run-time warning. That warning is emitted during project graph construction, so while the daemon is running it goes to `.nx/workspace-data/d/daemon.log` rather than the terminal; CI runs, where the daemon is disabled, print it normally.
+
+#### Sample code changes
+
+Given a project with a `build` target that uses the `@nx/angular:webpack-browser` executor:
+
+##### Before
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "build": {
+      "cache": true,
+      "dependsOn": ["^build"]
+    },
+    "@nx/angular:webpack-browser": {
+      "inputs": ["production", "^production"]
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "build": {
+      "cache": true,
+      "dependsOn": ["^build"]
+    },
+    "@nx/angular:webpack-browser": {
+      "inputs": ["production", "^production"],
+      "cache": true
+    }
+  }
+}
+```

package/dist/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -6,7 +6,7 @@ const child_process_1 = require("child_process");
 const output_1 = require("../../../utils/output");
 const json_1 = require("../../../generators/utils/json");
 const nx_json_1 = require("../../../generators/utils/nx-json");
-const format_changed_files_with_prettier_if_available_1 = require("../../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../../../generators/internal-utils/format-changed-files");
 const url_shorten_1 = require("../../utilities/url-shorten");
 const get_cloud_options_1 = require("../../utilities/get-cloud-options");
 const path_1 = require("path");
@@ -137,14 +137,14 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
     }
     if (responseFromCreateNxCloudWorkspaceV2) {
         addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
-        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+        await (0, format_changed_files_1.formatChangedFiles)(tree, {
             silent: schema.hideFormatLogs,
         });
         return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
     }
     else if (responseFromCreateNxCloudWorkspaceV1) {
         addNxCloudAccessTokenToNxJson(tree, responseFromCreateNxCloudWorkspaceV1?.token, schema.directory);
-        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+        await (0, format_changed_files_1.formatChangedFiles)(tree, {
             silent: schema.hideFormatLogs,
         });
         return responseFromCreateNxCloudWorkspaceV1.token;

package/dist/src/plugins/js/lock-file/bun-parser.js

@@ -12,6 +12,16 @@ const project_graph_1 = require("../../../config/project-graph");
 const file_hasher_1 = require("../../../hasher/file-hasher");
 const project_graph_builder_1 = require("../../../project-graph/project-graph-builder");
 const json_1 = require("../../../utils/json");
+// Highest bun.lock version this parser has been verified against:
+// - 1: workspace packages are no longer listed with their dependencies
+// - 2: identical content, stricter validation in Bun's own reader
+// - 3: values in "overrides" may be objects holding rules scoped to a parent
+//      package (`"parent": { "child": "1.0.0" }`) and keys may carry a version
+//      selector (`"parent@1"`, `"child@<2"`). This parser never reads
+//      "overrides"; the resolved packages are listed in "packages" as before.
+// Newer versions are parsed on a best-effort basis instead of being rejected
+// outright.
+const MAX_KNOWN_LOCKFILE_VERSION = 3;
 const DEPENDENCY_TYPES = [
     'dependencies',
     'devDependencies',
@@ -356,9 +366,12 @@ function parseLockFile(lockFileContent, lockFileHash) {
             if (typeof result.lockfileVersion !== 'number') {
                 throw new Error(`Lockfile version must be a number, got ${typeof result.lockfileVersion}`);
             }
-            const supportedVersions = [0, 1];
-            if (!supportedVersions.includes(result.lockfileVersion)) {
-                throw new Error(`Unsupported lockfile version ${result.lockfileVersion}. Supported versions: ${supportedVersions.join(', ')}`);
+            if (!Number.isInteger(result.lockfileVersion) ||
+                result.lockfileVersion < 0) {
+                throw new Error(`Unsupported lockfile version ${result.lockfileVersion}. Lockfile version must be a non-negative integer`);
+            }
+            if (result.lockfileVersion > MAX_KNOWN_LOCKFILE_VERSION) {
+                console.warn(`bun.lock has lockfileVersion ${result.lockfileVersion}, which is newer than the version ${MAX_KNOWN_LOCKFILE_VERSION} this version of Nx was tested with. Attempting to parse it anyway.`);
             }
         }
         if (!result.packages || typeof result.packages !== 'object') {
@@ -616,7 +629,7 @@ function processPackageForDependencies(packageKey, packageData, lockFile, index,
         const deps = packageDependencies[depType];
         if (!deps || typeof deps !== 'object')
             continue;
-        const depDependencies = processDependencyEntries(deps, sourceNodeName, index, ctx, workspacePackages, lockFile.manifests);
+        const depDependencies = processDependencyEntries(deps, packageKey, sourceNodeName, lockFile, index, ctx, workspacePackages);
         dependencies.push(...depDependencies);
     }
     return dependencies;
@@ -634,12 +647,12 @@ function extractPackageDependencies(packageData) {
     }
     return undefined;
 }
-function processDependencyEntries(deps, sourceNodeName, index, ctx, workspacePackages, manifests) {
+function processDependencyEntries(deps, sourcePackageKey, sourceNodeName, lockFile, index, ctx, workspacePackages) {
     const dependencies = [];
     const depsEntries = Object.entries(deps);
     for (const [packageName, versionSpec] of depsEntries) {
         try {
-            const dependency = processSingleDependency(packageName, versionSpec, sourceNodeName, index, ctx, workspacePackages, manifests);
+            const dependency = processSingleDependency(packageName, versionSpec, sourcePackageKey, sourceNodeName, lockFile, index, ctx, workspacePackages);
             if (dependency) {
                 dependencies.push(dependency);
             }
@@ -650,7 +663,7 @@ function processDependencyEntries(deps, sourceNodeName, index, ctx, workspacePac
     }
     return dependencies;
 }
-function processSingleDependency(packageName, versionSpec, sourceNodeName, index, ctx, workspacePackages, manifests) {
+function processSingleDependency(packageName, versionSpec, sourcePackageKey, sourceNodeName, lockFile, index, ctx, workspacePackages) {
     if (typeof packageName !== 'string' || typeof versionSpec !== 'string') {
         return null;
     }
@@ -663,14 +676,22 @@ function processSingleDependency(packageName, versionSpec, sourceNodeName, index
     }
     let targetPackageName = packageName;
     let targetVersion = versionSpec;
-    const aliasTarget = resolveAliasTarget(versionSpec);
-    if (aliasTarget) {
+    // A "<parent>/<name>" entry records what this parent actually resolved the
+    // dependency to. Overrides scoped to a parent (bun.lock v3) can pick a
+    // version outside the declared range, so it takes precedence over matching
+    // the range against the versions in the lockfile.
+    const nestedVersion = resolveNestedVersion(sourcePackageKey, packageName, lockFile);
+    const aliasTarget = nestedVersion ? null : resolveAliasTarget(versionSpec);
+    if (nestedVersion) {
+        targetVersion = nestedVersion;
+    }
+    else if (aliasTarget) {
         targetPackageName = aliasTarget.packageName;
         targetVersion = aliasTarget.version;
     }
     else {
         // O(1) lookup using index instead of O(n) scan
-        const resolvedVersion = findResolvedVersion(packageName, versionSpec, index, manifests);
+        const resolvedVersion = findResolvedVersion(packageName, versionSpec, index, lockFile.manifests);
         if (!resolvedVersion) {
             return null;
         }
@@ -693,6 +714,18 @@ function processSingleDependency(packageName, versionSpec, sourceNodeName, index
         return null;
     }
 }
+function resolveNestedVersion(sourcePackageKey, packageName, lockFile) {
+    const nestedEntry = lockFile.packages[`${sourcePackageKey}/${packageName}`];
+    if (!Array.isArray(nestedEntry) || typeof nestedEntry[0] !== 'string') {
+        return null;
+    }
+    const { name, version } = getCachedSpecInfo(nestedEntry[0]);
+    // aliases ("alias@npm:real@1.0.0") are resolved to the real package by the caller
+    if (name !== packageName || !version || version.startsWith('npm:')) {
+        return null;
+    }
+    return version;
+}
 function resolveTargetNodeName(targetPackageName, targetVersion, ctx) {
     const hoistedNodeName = `npm:${targetPackageName}`;
     const versionedNodeName = `npm:${targetPackageName}@${targetVersion}`;