@nx/js 23.2.0-beta.0 → 23.2.0-beta.10

package/dist/src/utils/npm-config.d.ts

@@ -1,4 +1,4 @@
-import { PackageJson } from 'nx/src/utils/package-json';
+import { PackageJson } from '@nx/devkit/internal';
 export declare function parseRegistryOptions(cwd: string, pkg: {
     packageRoot: string;
     packageJson: PackageJson;

package/dist/src/utils/nx-formatter-internals.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `@nx/js` inherits `@nx/devkit`'s `nx` peer, which spans a major either
+ * side, so an older nx without these helpers can legally be installed. A
+ * missing CommonJS named export arrives as `undefined`, so the first use
+ * would otherwise be a bare `undefined.every` naming neither package nor
+ * cause.
+ */
+export declare function assertNxSupportsFormatters(): void;

package/dist/src/utils/nx-formatter-internals.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNxSupportsFormatters = assertNxSupportsFormatters;
+const internal_1 = require("@nx/devkit/internal");
+/**
+ * `@nx/js` inherits `@nx/devkit`'s `nx` peer, which spans a major either
+ * side, so an older nx without these helpers can legally be installed. A
+ * missing CommonJS named export arrives as `undefined`, so the first use
+ * would otherwise be a bare `undefined.every` naming neither package nor
+ * cause.
+ */
+function assertNxSupportsFormatters() {
+    if (internal_1.detectFormatterInTree && internal_1.oxfmtConfigFiles && internal_1.prettierConfigFiles) {
+        return;
+    }
+    throw new Error('The installed version of nx does not export the formatter helpers that @nx/js needs to detect and set up a formatter. ' +
+        'This happens when nx and @nx/js are on different major versions. Run `nx migrate latest` to bring them into line.');
+}

package/dist/src/utils/oxfmt.d.ts

@@ -0,0 +1,4 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export declare function generateOxfmtSetup(tree: Tree, options: {
+    skipPackageJson?: boolean;
+}): GeneratorCallback;

package/dist/src/utils/oxfmt.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOxfmtSetup = generateOxfmtSetup;
+const devkit_1 = require("@nx/devkit");
+// Imported rather than copied: detection ("is this workspace using oxfmt?")
+// and setup ("should a config be written?") have to agree on the same list, or
+// a workspace that already has a config gets a second, redundant one.
+const internal_1 = require("@nx/devkit/internal");
+const nx_formatter_internals_1 = require("./nx-formatter-internals");
+const versions_1 = require("./versions");
+function generateOxfmtSetup(tree, options) {
+    (0, nx_formatter_internals_1.assertNxSupportsFormatters)();
+    if (internal_1.oxfmtConfigFiles.every((name) => !tree.exists(name))) {
+        // oxfmt defaults to double quotes and we prefer single, so that is the one
+        // option worth setting. Line width is left at oxfmt's default.
+        (0, devkit_1.writeJson)(tree, '.oxfmtrc.json', { singleQuote: true });
+    }
+    // The oxc extension is what drives oxfmt in the editor, so recommend it for
+    // the same reason the prettier setup recommends its own. Only when the file
+    // is already there - creating it would push an editor choice on a workspace
+    // that has not made one.
+    if (tree.exists('.vscode/extensions.json')) {
+        (0, devkit_1.updateJson)(tree, '.vscode/extensions.json', (json) => {
+            json.recommendations ??= [];
+            const extension = 'oxc.oxc-vscode';
+            if (!json.recommendations.includes(extension)) {
+                json.recommendations.push(extension);
+            }
+            return json;
+        });
+    }
+    return options.skipPackageJson
+        ? () => { }
+        : (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { oxfmt: versions_1.oxfmtVersion });
+}

package/dist/src/utils/package-json/update-package-json.d.ts

@@ -1,6 +1,6 @@
+import { type PackageJson } from '@nx/devkit/internal';
 import { ExecutorContext, ProjectFileMap, ProjectGraphProjectNode } from '@nx/devkit';
 import { DependentBuildableProjectNode } from '../buildable-libs-utils';
-import type { PackageJson } from 'nx/src/utils/package-json';
 export type SupportedFormat = 'cjs' | 'esm';
 export interface UpdatePackageJsonOption {
     rootDir?: string;

package/dist/src/utils/package-json/update-package-json.js

@@ -4,24 +4,19 @@ exports.updatePackageJson = updatePackageJson;
 exports.getExports = getExports;
 exports.getUpdatedPackageJsonContent = getUpdatedPackageJsonContent;
 exports.getOutputDir = getOutputDir;
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
-// eslint-disable-next-line @typescript-eslint/no-restricted-imports
-const create_package_json_1 = require("nx/src/plugins/js/package-json/create-package-json");
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const node_fs_1 = require("node:fs");
 const path_1 = require("path");
-const fileutils_1 = require("nx/src/utils/fileutils");
-const nx_deps_cache_1 = require("nx/src/project-graph/nx-deps-cache");
 const get_main_file_dir_1 = require("../get-main-file-dir");
 const strip_glob_to_base_dir_1 = require("../strip-glob-to-base-dir");
 function updatePackageJson(options, context, target, dependencies, fileMap = null) {
     let packageJson;
     if (fileMap == null) {
-        fileMap = (0, nx_deps_cache_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
+        fileMap = (0, internal_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
     }
     if (options.updateBuildableProjectDepsInPackageJson) {
-        packageJson = (0, create_package_json_1.createPackageJson)(context.projectName, context.projectGraph, {
+        packageJson = (0, internal_1.createPackageJson)(context.projectName, context.projectGraph, {
             target: context.targetName,
             root: context.root,
             // By default we remove devDependencies since this is a production build.
@@ -34,7 +29,7 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
     }
     else {
         const pathToPackageJson = (0, path_1.join)(context.root, options.projectRoot, 'package.json');
-        packageJson = (0, fileutils_1.fileExists)(pathToPackageJson)
+        packageJson = (0, internal_1.fileExists)(pathToPackageJson)
             ? (0, devkit_1.readJsonFile)(pathToPackageJson)
             : { name: context.projectName, version: '0.0.1' };
     }
@@ -50,22 +45,16 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
         }
         options.format = ['cjs'];
     }
-    // update package specific settings
     packageJson = getUpdatedPackageJsonContent(packageJson, options);
-    // save files
-    (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
+    const packageManager = (0, devkit_1.detectPackageManager)(context.root);
     if (options.generateLockfile) {
-        const packageManager = (0, devkit_1.detectPackageManager)(context.root);
-        if (packageManager === 'bun') {
-            devkit_1.logger.warn(`Bun lockfile generation is unsupported. Remove "generateLockfile" option or set it to false.`);
-        }
-        else {
-            const lockFile = (0, lock_file_1.createLockFile)(packageJson, context.projectGraph, packageManager);
-            (0, node_fs_1.writeFileSync)(`${options.outputPath}/${(0, lock_file_1.getLockFileName)(packageManager)}`, lockFile, {
-                encoding: 'utf-8',
-            });
-        }
+        (0, internal_1.generatePrunedDeployOutput)(packageJson, context.projectGraph, options.projectRoot, {
+            outputDirectory: options.outputPath,
+            packageManager,
+            workspaceRoot: context.root,
+        });
     }
+    (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
 }
 function isNpmNode(node, graph) {
     return !!(graph.externalNodes[node.name]?.type === 'npm');

package/dist/src/utils/package-manager-workspaces.js

@@ -8,8 +8,8 @@ exports.getProjectPackageManagerWorkspaceStateWarningTask = getProjectPackageMan
 const devkit_1 = require("@nx/devkit");
 const picomatch = require("picomatch");
 const posix_1 = require("node:path/posix");
-const package_json_1 = require("nx/src/plugins/package-json");
 const semver_1 = require("semver");
+const internal_1 = require("@nx/devkit/internal");
 function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     if (!isUsingPackageManagerWorkspaces(tree)) {
         return 'no-workspaces';
@@ -19,7 +19,7 @@ function getProjectPackageManagerWorkspaceState(tree, projectRoot) {
     return isIncluded ? 'included' : 'excluded';
 }
 function getPackageManagerWorkspacesPatterns(tree) {
-    return (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }), (path) => {
+    return (0, internal_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (path) => (0, devkit_1.readJson)(tree, path, { expectComments: true }), (path) => {
         const content = tree.read(path, 'utf-8');
         const { load } = require('@zkochan/js-yaml');
         return load(content, { filename: path });

package/dist/src/utils/pnpm-deploy-output-cache-inputs.d.ts

@@ -0,0 +1,29 @@
+import type { TargetDefaults } from '@nx/devkit';
+import { type MatchedTargetRef } from './target-defaults-matching';
+/**
+ * Adds the missing `PNPM_INSTALL_SETTINGS_INPUTS` to the layer whose `inputs`
+ * array the runtime actually uses for this target: the target's own `inputs`
+ * when it declares them (its array replaces the defaults' rather than merging
+ * with it), otherwise the matching `targetDefaults` entry supplying the array
+ * it inherits, and otherwise the target itself with nx's own default spelled
+ * out first, so nothing that was hashed stops being hashed. Sources the
+ * effective inputs already hash, including via a whole-file root package.json
+ * fileset or a `json` input covering the settings fields, are left alone; no
+ * `'...'` is ever authored. Returns which layer was mutated, or null when
+ * nothing was missing.
+ */
+export declare function addPnpmDeployOutputCacheInputs(ref: MatchedTargetRef, targetDefaults: TargetDefaults | undefined, executor: string): 'target' | 'defaults' | null;
+/**
+ * Variant for a plugin-inferred target, whose generated `inputs` already carry
+ * the settings sources (the runtime probe only while the root manifest has no
+ * valid pnpm pin): a repair is only needed when an overlay (a project-level
+ * target entry, exact or glob key, or a matching `targetDefaults` entry)
+ * supplies a replacing `inputs` array that discards them. The repair appends
+ * the full set, probe included, because it runs once and the pin can be
+ * removed later. The inferred layer is modeled as an array of exactly the
+ * settings inputs: enough for the missing check, and it makes an overlay-less
+ * target come back as nothing missing, so the fallback that would narrow the
+ * plugin's richer array to `DEFAULT_INPUTS` can never be reached: with no
+ * replacing supplier there is nothing to mutate.
+ */
+export declare function addPnpmDeployOutputCacheInputsToInferredTargetOverlay(ref: MatchedTargetRef, targetDefaults: TargetDefaults | undefined): 'target' | 'defaults' | null;

package/dist/src/utils/pnpm-deploy-output-cache-inputs.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPnpmDeployOutputCacheInputs = addPnpmDeployOutputCacheInputs;
+exports.addPnpmDeployOutputCacheInputsToInferredTargetOverlay = addPnpmDeployOutputCacheInputsToInferredTargetOverlay;
+const internal_1 = require("@nx/devkit/internal");
+const pnpm_install_settings_inputs_1 = require("./pnpm-install-settings-inputs");
+const target_defaults_matching_1 = require("./target-defaults-matching");
+const ROOT_MANIFEST = '{workspaceRoot}/package.json';
+const MANIFEST_SETTINGS_FIELDS = new Set(pnpm_install_settings_inputs_1.PNPM_INSTALL_SETTINGS_INPUTS.filter((input) => typeof input !== 'string' && 'json' in input).flatMap((input) => input.fields ?? []));
+/**
+ * Adds the missing `PNPM_INSTALL_SETTINGS_INPUTS` to the layer whose `inputs`
+ * array the runtime actually uses for this target: the target's own `inputs`
+ * when it declares them (its array replaces the defaults' rather than merging
+ * with it), otherwise the matching `targetDefaults` entry supplying the array
+ * it inherits, and otherwise the target itself with nx's own default spelled
+ * out first, so nothing that was hashed stops being hashed. Sources the
+ * effective inputs already hash, including via a whole-file root package.json
+ * fileset or a `json` input covering the settings fields, are left alone; no
+ * `'...'` is ever authored. Returns which layer was mutated, or null when
+ * nothing was missing.
+ */
+function addPnpmDeployOutputCacheInputs(ref, targetDefaults, executor) {
+    const selectedKey = targetDefaults
+        ? (0, target_defaults_matching_1.selectDefaultsKey)(ref, targetDefaults, executor)
+        : null;
+    const entries = (0, target_defaults_matching_1.compatibleDefaultsEntries)(ref, selectedKey, targetDefaults);
+    const defaults = entries.length
+        ? (0, internal_1.readTargetDefaultsForTarget)(ref.targetName, { [selectedKey]: entries }, ref.matcherExecutor, {
+            projectName: ref.projectName,
+            projectNode: ref.projectNode,
+            sourcePlugin: ref.sourcePlugin,
+        })
+        : null;
+    const effective = (0, internal_1.mergeTargetConfigurations)(ref.target, defaults ?? {});
+    const missing = missingSettingsInputs(effective.inputs);
+    if (missing.length === 0) {
+        return null;
+    }
+    if (ref.target.inputs !== undefined) {
+        appendInputs(ref.target, missing);
+        return 'target';
+    }
+    const supplier = (0, target_defaults_matching_1.lastMatchingInputsSupplier)(ref, selectedKey, entries);
+    if (supplier) {
+        appendInputs(supplier, missing);
+        return 'defaults';
+    }
+    appendInputs(ref.target, missing);
+    return 'target';
+}
+/**
+ * Variant for a plugin-inferred target, whose generated `inputs` already carry
+ * the settings sources (the runtime probe only while the root manifest has no
+ * valid pnpm pin): a repair is only needed when an overlay (a project-level
+ * target entry, exact or glob key, or a matching `targetDefaults` entry)
+ * supplies a replacing `inputs` array that discards them. The repair appends
+ * the full set, probe included, because it runs once and the pin can be
+ * removed later. The inferred layer is modeled as an array of exactly the
+ * settings inputs: enough for the missing check, and it makes an overlay-less
+ * target come back as nothing missing, so the fallback that would narrow the
+ * plugin's richer array to `DEFAULT_INPUTS` can never be reached: with no
+ * replacing supplier there is nothing to mutate.
+ */
+function addPnpmDeployOutputCacheInputsToInferredTargetOverlay(ref, targetDefaults) {
+    const selectedKey = targetDefaults
+        ? (0, target_defaults_matching_1.selectDefaultsKey)(ref, targetDefaults, ref.matcherExecutor)
+        : null;
+    const entries = (0, target_defaults_matching_1.compatibleDefaultsEntries)(ref, selectedKey, targetDefaults);
+    const defaults = entries.length
+        ? (0, internal_1.readTargetDefaultsForTarget)(ref.targetName, { [selectedKey]: entries }, ref.matcherExecutor, {
+            projectName: ref.projectName,
+            projectNode: ref.projectNode,
+            sourcePlugin: ref.sourcePlugin,
+        })
+        : null;
+    const inferredLayer = {
+        inputs: [...pnpm_install_settings_inputs_1.PNPM_INSTALL_SETTINGS_INPUTS],
+    };
+    const effective = (0, internal_1.mergeTargetConfigurations)(ref.target, (0, internal_1.mergeTargetConfigurations)(defaults ?? {}, inferredLayer));
+    const missing = missingSettingsInputs(effective.inputs);
+    if (missing.length === 0) {
+        return null;
+    }
+    if (ref.target.inputs !== undefined) {
+        appendInputs(ref.target, missing);
+        return 'target';
+    }
+    const supplier = (0, target_defaults_matching_1.lastMatchingInputsSupplier)(ref, selectedKey, entries);
+    if (supplier) {
+        appendInputs(supplier, missing);
+        return 'defaults';
+    }
+    return null;
+}
+/**
+ * The settings sources the effective inputs do not hash yet. The manifest
+ * counts as covered by a whole-file fileset no negative pattern can cancel,
+ * or by an existing `json` input that hashes all the settings fields (`json`
+ * inputs are immune to fileset negations); the workspace yaml by its fileset
+ * (a negative pattern cancelling that fileset has no input-level counter, so
+ * it is left to the author who wrote it); the runtime probe by an identical
+ * `runtime` entry.
+ */
+function missingSettingsInputs(inputs) {
+    const filesets = (0, target_defaults_matching_1.namedFilesets)(inputs);
+    const missing = [];
+    for (const input of pnpm_install_settings_inputs_1.PNPM_INSTALL_SETTINGS_INPUTS) {
+        if (typeof input === 'string') {
+            if (!filesets.has(input)) {
+                missing.push(input);
+            }
+        }
+        else if ('runtime' in input) {
+            if (!(inputs ?? []).some((existing) => typeof existing === 'object' &&
+                existing !== null &&
+                'runtime' in existing &&
+                existing.runtime === input.runtime)) {
+                missing.push(input);
+            }
+        }
+        else if (!(filesets.has(ROOT_MANIFEST) && !negationMayCancel(inputs)) &&
+            !(inputs ?? []).some((existing) => typeof existing === 'object' &&
+                existing !== null &&
+                'json' in existing &&
+                existing.json === ROOT_MANIFEST &&
+                [...MANIFEST_SETTINGS_FIELDS].every((field) => jsonInputCoversField(existing, field)))) {
+            missing.push(input);
+        }
+    }
+    return missing;
+}
+/**
+ * Whether a negative fileset entry could remove the source from the hash. Any
+ * workspace-root-scoped negation counts, in the string or `{ fileset }` form:
+ * nx's pattern syntax (globs, extglobs) is not re-evaluated here, and an
+ * extra input for a source the negation does not actually touch is harmless.
+ * Project-relative negations never match a workspace-root file.
+ */
+function negationMayCancel(inputs) {
+    return (inputs ?? []).some((existing) => {
+        const pattern = typeof existing === 'string'
+            ? existing
+            : typeof existing === 'object' &&
+                existing !== null &&
+                'fileset' in existing
+                ? existing.fileset
+                : undefined;
+        return (typeof pattern === 'string' &&
+            pattern.startsWith('!') &&
+            pattern.includes('{workspaceRoot}'));
+    });
+}
+/**
+ * Whether an existing `json` input hashes `field`: selected by the allowlist
+ * (an entry covers its whole subtree) and not touched by the denylist, which
+ * the hasher applies after selection. A denylist entry below the field only
+ * removes part of its subtree, but that part is then unhashed, so it
+ * disqualifies coverage too.
+ */
+function jsonInputCoversField(input, field) {
+    const selected = input.fields === undefined ||
+        input.fields.some((path) => path === field || field.startsWith(`${path}.`));
+    if (!selected) {
+        return false;
+    }
+    return !(input.excludeFields ?? []).some((path) => path === field ||
+        field.startsWith(`${path}.`) ||
+        path.startsWith(`${field}.`));
+}
+/**
+ * Appends to an array that already exists, or writes nx's default as the base
+ * when no layer declares one, so the configuration is never narrowed to the
+ * settings sources alone.
+ */
+function appendInputs(config, missing) {
+    config.inputs = [...(config.inputs ?? target_defaults_matching_1.DEFAULT_INPUTS), ...missing];
+}

package/dist/src/utils/pnpm-install-settings-inputs.d.ts

@@ -0,0 +1,45 @@
+import { type PackageManager } from '@nx/devkit';
+import { type JsonInput } from '@nx/devkit/internal';
+/**
+ * Task inputs covering the sources of the pnpm install settings a pruned
+ * deploy output carries (build-script approvals, `supportedArchitectures`,
+ * `patchedDependencies`). Nothing else in a build target's default hash moves
+ * when an approval is revoked, so a target that emits the deploy output must
+ * hash these or a cached run replays an output that still grants it. The
+ * manifest is narrowed to the fields the output is built from so dependency
+ * bumps in the root package.json do not invalidate every build.
+ *
+ * The pnpm major selects which emitted file carries the settings (pnpm 11+
+ * reads them from pnpm-workspace.yaml, pnpm <=10 from the emitted
+ * package.json). The manifest's `packageManager` field pins it when it
+ * parses to a pnpm version; the runtime probe covers the ambient binary that
+ * decides it otherwise, printing only the major so pnpm patch and minor
+ * releases do not move the hash, and a sentinel when the binary is missing
+ * (the hasher records the probe's output without checking its exit status,
+ * so a missing binary does not fail the hash). The full set keeps the probe
+ * even under a valid pin: the generator and the migrations write inputs
+ * once, and the pin can be removed later. Plugins re-infer on every graph
+ * build, so they use {@link pnpmInstallSettingsInputsForInferredTarget} to
+ * add the probe only while no valid pin exists.
+ *
+ * The contents of vendored non-workspace local-path dependencies also ship in
+ * the deploy output but are not covered: their set is derived from the
+ * lockfile at build time, so no static input list stays correct as
+ * dependencies change. Covering them needs content hashing at the graph level
+ * (the pnpm parser's directory/link external nodes hash only name and path).
+ */
+export declare const PNPM_MAJOR_RUNTIME_INPUT: {
+    runtime: string;
+};
+export declare const PNPM_INSTALL_SETTINGS_INPUTS: (string | JsonInput | {
+    runtime: string;
+})[];
+export declare function pnpmInstallSettingsInputsForInferredTarget(includePnpmMajorRuntimeInput: boolean): (string | JsonInput | {
+    runtime: string;
+})[];
+/**
+ * Whether an inferred build target needs the runtime probe: the workspace uses
+ * pnpm and the root `packageManager` field does not pin a pnpm version. A
+ * missing or unreadable root manifest cannot pin one, so it counts as no pin.
+ */
+export declare function shouldIncludePnpmMajorRuntimeInput(packageManager: PackageManager, workspaceRoot: string): boolean;

package/dist/src/utils/pnpm-install-settings-inputs.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNPM_INSTALL_SETTINGS_INPUTS = exports.PNPM_MAJOR_RUNTIME_INPUT = void 0;
+exports.pnpmInstallSettingsInputsForInferredTarget = pnpmInstallSettingsInputsForInferredTarget;
+exports.shouldIncludePnpmMajorRuntimeInput = shouldIncludePnpmMajorRuntimeInput;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const path_1 = require("path");
+/**
+ * Task inputs covering the sources of the pnpm install settings a pruned
+ * deploy output carries (build-script approvals, `supportedArchitectures`,
+ * `patchedDependencies`). Nothing else in a build target's default hash moves
+ * when an approval is revoked, so a target that emits the deploy output must
+ * hash these or a cached run replays an output that still grants it. The
+ * manifest is narrowed to the fields the output is built from so dependency
+ * bumps in the root package.json do not invalidate every build.
+ *
+ * The pnpm major selects which emitted file carries the settings (pnpm 11+
+ * reads them from pnpm-workspace.yaml, pnpm <=10 from the emitted
+ * package.json). The manifest's `packageManager` field pins it when it
+ * parses to a pnpm version; the runtime probe covers the ambient binary that
+ * decides it otherwise, printing only the major so pnpm patch and minor
+ * releases do not move the hash, and a sentinel when the binary is missing
+ * (the hasher records the probe's output without checking its exit status,
+ * so a missing binary does not fail the hash). The full set keeps the probe
+ * even under a valid pin: the generator and the migrations write inputs
+ * once, and the pin can be removed later. Plugins re-infer on every graph
+ * build, so they use {@link pnpmInstallSettingsInputsForInferredTarget} to
+ * add the probe only while no valid pin exists.
+ *
+ * The contents of vendored non-workspace local-path dependencies also ship in
+ * the deploy output but are not covered: their set is derived from the
+ * lockfile at build time, so no static input list stays correct as
+ * dependencies change. Covering them needs content hashing at the graph level
+ * (the pnpm parser's directory/link external nodes hash only name and path).
+ */
+exports.PNPM_MAJOR_RUNTIME_INPUT = {
+    runtime: `node -e "try{console.log('pnpm major '+require('child_process').execSync('pnpm --version',{stdio:['ignore','pipe','ignore']}).toString().trim().split('.')[0])}catch{console.log('pnpm major unavailable')}"`,
+};
+const PNPM_INSTALL_SETTINGS_FILE_INPUTS = [
+    '{workspaceRoot}/pnpm-workspace.yaml',
+    {
+        json: '{workspaceRoot}/package.json',
+        fields: [
+            'packageManager',
+            'pnpm.onlyBuiltDependencies',
+            'pnpm.neverBuiltDependencies',
+            'pnpm.allowBuilds',
+            'pnpm.supportedArchitectures',
+            'pnpm.patchedDependencies',
+        ],
+    },
+];
+exports.PNPM_INSTALL_SETTINGS_INPUTS = [...PNPM_INSTALL_SETTINGS_FILE_INPUTS, exports.PNPM_MAJOR_RUNTIME_INPUT];
+function pnpmInstallSettingsInputsForInferredTarget(includePnpmMajorRuntimeInput) {
+    return includePnpmMajorRuntimeInput
+        ? [...PNPM_INSTALL_SETTINGS_FILE_INPUTS, exports.PNPM_MAJOR_RUNTIME_INPUT]
+        : [...PNPM_INSTALL_SETTINGS_FILE_INPUTS];
+}
+/**
+ * Whether an inferred build target needs the runtime probe: the workspace uses
+ * pnpm and the root `packageManager` field does not pin a pnpm version. A
+ * missing or unreadable root manifest cannot pin one, so it counts as no pin.
+ */
+function shouldIncludePnpmMajorRuntimeInput(packageManager, workspaceRoot) {
+    if (packageManager !== 'pnpm') {
+        return false;
+    }
+    let field;
+    try {
+        field = (0, devkit_1.readJsonFile)((0, path_1.join)(workspaceRoot, 'package.json'))?.packageManager;
+    }
+    catch {
+        field = undefined;
+    }
+    return ((0, internal_1.parseVersionFromPackageManagerField)('pnpm', typeof field === 'string' ? field : undefined) === null);
+}

package/dist/src/utils/prettier.js

@@ -4,6 +4,8 @@ exports.resolveUserExistingPrettierConfig = resolveUserExistingPrettierConfig;
 exports.generatePrettierSetup = generatePrettierSetup;
 exports.resolvePrettierConfigPath = resolvePrettierConfigPath;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const nx_formatter_internals_1 = require("./nx-formatter-internals");
 const versions_1 = require("./versions");
 // 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
@@ -44,22 +46,11 @@ async function resolveUserExistingPrettierConfig() {
     }
 }
 function generatePrettierSetup(tree, options) {
-    // https://prettier.io/docs/en/configuration.html
-    const prettierrcNameOptions = [
-        '.prettierrc',
-        '.prettierrc.json',
-        '.prettierrc.yml',
-        '.prettierrc.yaml',
-        '.prettierrc.json5',
-        '.prettierrc.js',
-        '.prettierrc.cjs',
-        '.prettierrc.mjs',
-        '.prettierrc.toml',
-        'prettier.config.js',
-        'prettier.config.cjs',
-        'prettier.config.mjs',
-    ];
-    if (prettierrcNameOptions.every((name) => !tree.exists(name))) {
+    (0, nx_formatter_internals_1.assertNxSupportsFormatters)();
+    // Imported rather than copied: detection and setup have to agree on this
+    // list, or a workspace whose config format is missing from one side gets a
+    // second, redundant `.prettierrc` written beside the one it already has.
+    if (internal_1.prettierConfigFiles.every((name) => !tree.exists(name))) {
         (0, devkit_1.writeJson)(tree, '.prettierrc', { singleQuote: true });
     }
     if (!tree.exists('.prettierignore')) {
@@ -68,6 +59,7 @@ function generatePrettierSetup(tree, options) {
         /coverage
         /.nx/cache
         /.nx/workspace-data
+        ${(0, internal_1.getLockFileName)((0, devkit_1.detectPackageManager)(tree.root))}
       `);
     }
     if (tree.exists('.vscode/extensions.json')) {
@@ -85,6 +77,7 @@ function generatePrettierSetup(tree, options) {
         : (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { prettier: versions_1.prettierVersion });
 }
 async function resolvePrettierConfigPath(tree) {
+    (0, nx_formatter_internals_1.assertNxSupportsFormatters)();
     const prettier = await importPrettier();
     if (!prettier) {
         return null;
@@ -96,23 +89,11 @@ async function resolvePrettierConfigPath(tree) {
     if (!tree) {
         return null;
     }
-    // if we haven't find a config file in the file system, we try to find it in the virtual tree
-    // https://prettier.io/docs/en/configuration.html
-    const prettierrcNameOptions = [
-        '.prettierrc',
-        '.prettierrc.json',
-        '.prettierrc.yml',
-        '.prettierrc.yaml',
-        '.prettierrc.json5',
-        '.prettierrc.js',
-        '.prettierrc.cjs',
-        '.prettierrc.mjs',
-        '.prettierrc.toml',
-        'prettier.config.js',
-        'prettier.config.cjs',
-        'prettier.config.mjs',
-    ];
-    const filePath = prettierrcNameOptions.find((file) => tree.exists(file));
+    // Same shared list as the setup above, so a config this can't see is one the
+    // setup would overwrite. The copy this replaced was missing the `.ts`,
+    // `.mts` and `.cts` forms.
+    // https://prettier.io/docs/configuration
+    const filePath = internal_1.prettierConfigFiles.find((file) => tree.exists(file));
     if (filePath) {
         return filePath;
     }

package/dist/src/utils/target-defaults-matching.d.ts

@@ -0,0 +1,57 @@
+import type { ProjectGraphProjectNode, TargetConfiguration, TargetDefaultArrayEntry, TargetDefaults } from '@nx/devkit';
+export declare const DEFAULT_INPUTS: string[];
+/** Everything the runtime's `targetDefaults` matcher needs to resolve a target. */
+export interface DefaultsMatchContext {
+    targetName: string;
+    projectName: string;
+    projectNode: ProjectGraphProjectNode;
+    matcherExecutor: string | undefined;
+    sourcePlugin?: string;
+}
+export interface MatchedTargetRef extends DefaultsMatchContext {
+    target: TargetConfiguration;
+}
+/**
+ * A matched target with the `targetDefaults` key the runtime would resolve for
+ * it, carried together so the two cannot fall out of step.
+ */
+export interface KeyedTargetRef {
+    ref: MatchedTargetRef;
+    selectedKey: string | null;
+}
+/**
+ * The `targetDefaults` entries under the selected key that survive nx's own
+ * per-entry compatibility guard. Graph construction selects the key, then drops
+ * each entry whose identity is incompatible with the target's *original* one and
+ * keeps the compatible siblings (`createTargetDefaultsResults` in nx's
+ * target-defaults). Reading the key unfiltered instead would let a
+ * foreign-executor entry contribute outputs the target never gets.
+ */
+export declare function compatibleDefaultsEntries(ref: MatchedTargetRef, selectedKey: string | null, targetDefaults: TargetDefaults | undefined): TargetDefaultArrayEntry[];
+/**
+ * The last entry under the selected key that both matches the target (the
+ * entry's own filter included) and declares `inputs`: the runtime merge makes
+ * that entry's array the one the target inherits. A later entry that declares
+ * `inputs` behind a filter not matching this target supplies some other
+ * target's array, so it cannot be the layer to mutate.
+ */
+export declare function lastMatchingInputsSupplier(ref: MatchedTargetRef, selectedKey: string, entries: TargetDefaultArrayEntry[]): TargetDefaultArrayEntry | undefined;
+/** The plain filesets an inputs array names, for a containment check. */
+export declare function namedFilesets(inputs: TargetConfiguration['inputs']): ReadonlySet<string>;
+/**
+ * The executor an executor-less target ends up with after its selected
+ * defaults key applies. Each matching entry's identity is resolved like the
+ * runtime does at merge time: a `command` payload means nx:run-commands, and
+ * a later entry's identity replaces an earlier, incompatible one (the reader's
+ * merged view keeps the first executor instead, so it cannot be used here).
+ */
+export declare function resolveDefaultsExecutor(targetName: string, projectName: string, projectNode: ProjectGraphProjectNode, targetDefaults: TargetDefaults | undefined, executorKeyCandidate?: string): string | undefined;
+/**
+ * The `targetDefaults` key nx's runtime would select for this target: keys
+ * are tried as the executor key, the exact-name key, then glob keys longest
+ * first, and the first whose entries produce a match wins; the rest are
+ * shadowed. Resolution per key goes through nx's own reader. Non-matching
+ * keys never resolve, so sorting all remaining keys by length stands in for
+ * the runtime's glob-only ordering.
+ */
+export declare function selectDefaultsKey(ref: DefaultsMatchContext, targetDefaults: TargetDefaults, executorKeyCandidate?: string): string | null;