nx 23.0.0-beta.5 → 23.0.0-beta.7

package/dist/plugins/package-json.js

@@ -8,6 +8,7 @@ const cache_directory_1 = require("../src/utils/cache-directory");
 const path_1 = require("path");
 const fileutils_1 = require("../src/utils/fileutils");
 const plugin_cache_utils_1 = require("../src/utils/plugin-cache-utils");
+const package_manager_1 = require("../src/utils/package-manager");
 const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'package-json.hash');
 let packageJsonPluginCache = null;
 function readPackageJsonConfigurationCache() {
@@ -16,7 +17,7 @@ function readPackageJsonConfigurationCache() {
 }
 function writeCache() {
     if (packageJsonPluginCache) {
-        packageJsonPluginCache.writeToDisk(cachePath);
+        packageJsonPluginCache.writeToDisk();
     }
 }
 const plugin = {
@@ -27,7 +28,8 @@ const plugin = {
             const cache = readPackageJsonConfigurationCache();
             const patterns = (0, package_json_1.buildPackageJsonPatterns)(context.workspaceRoot, (f) => (0, fileutils_1.readJsonFile)((0, path_1.join)(context.workspaceRoot, f)));
             const isInPackageJsonWorkspaces = (0, package_json_1.buildPackageJsonWorkspacesMatcher)(patterns);
-            const result = (0, plugins_1.createNodesFromFiles)((packageJsonPath) => (0, package_json_1.createNodeFromPackageJson)(packageJsonPath, workspace_root_1.workspaceRoot, cache, isInPackageJsonWorkspaces(packageJsonPath)), configFiles, options, context);
+            const packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(context.workspaceRoot), context.workspaceRoot);
+            const result = (0, plugins_1.createNodesFromFiles)((packageJsonPath) => (0, package_json_1.createNodeFromPackageJson)(packageJsonPath, workspace_root_1.workspaceRoot, cache, isInPackageJsonWorkspaces(packageJsonPath), packageManagerCommand), configFiles, options, context);
             writeCache();
             return result;
         },

package/dist/src/analytics/analytics.js

@@ -16,6 +16,7 @@ const native_1 = require("../native");
 const package_manager_1 = require("../utils/package-manager");
 const semver_1 = require("semver");
 const os = tslib_1.__importStar(require("os"));
+const crypto_1 = require("crypto");
 const machine_id_cache_1 = require("../utils/machine-id-cache");
 const is_ci_1 = require("../utils/is-ci");
 const analytics_prompt_1 = require("../utils/analytics-prompt");
@@ -56,7 +57,7 @@ async function startAnalytics() {
         return;
     }
     const isNxCloud = !!(nxJson?.nxCloudId ?? nxJson?.nxCloudAccessToken);
-    const userId = await (0, machine_id_cache_1.getCurrentMachineId)();
+    const userId = await getTelemetryUserId(workspaceId);
     const packageManagerInfo = getPackageManagerInfo();
     const nodeVersion = (0, semver_1.parse)(process.version);
     const nodeVersionString = nodeVersion
@@ -225,3 +226,11 @@ function isAnalyticsEnabled() {
     const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
     return nxJson?.analytics === true;
 }
+// Mix workspace id in: shared Docker images (Gitpod, Cypress, etc.) bake
+// in /etc/machine-id, so machine-id alone collapses many users into one.
+async function getTelemetryUserId(workspaceId) {
+    const machineId = await (0, machine_id_cache_1.getCurrentMachineId)();
+    return (0, crypto_1.createHash)('sha256')
+        .update(`${machineId}|${workspaceId}`)
+        .digest('hex');
+}

package/dist/src/config/task-graph.d.ts

@@ -1,109 +1,6 @@
 /**
- * A representation of the invocation of an Executor
+ * `Task` and `TaskGraph` are defined as Rust structs in
+ * `packages/nx/src/native/tasks/types.rs` and exposed to TypeScript via NAPI.
+ * This file re-exports them so existing imports keep working.
  */
-export interface Task {
-    /**
-     * Unique ID
-     */
-    id: string;
-    /**
-     * Details about which project, target, and configuration to run.
-     */
-    target: {
-        /**
-         * The project for which the task belongs to
-         */
-        project: string;
-        /**
-         * The target name which the task should invoke
-         */
-        target: string;
-        /**
-         * The configuration of the target which the task invokes
-         */
-        configuration?: string;
-    };
-    /**
-     * Overrides for the configured options of the target
-     */
-    overrides: any;
-    /**
-     * The outputs the task may produce
-     */
-    outputs: string[];
-    /**
-     * Root of the project the task belongs to
-     */
-    projectRoot?: string;
-    /**
-     * Hash of the task which is used for caching.
-     */
-    hash?: string;
-    /**
-     * Details about the composition of the hash
-     */
-    hashDetails?: {
-        /**
-         * Command of the task
-         */
-        command: string;
-        /**
-         * Hashes of inputs used in the hash
-         */
-        nodes: {
-            [name: string]: string;
-        };
-        /**
-         * Hashes of implicit dependencies which are included in the hash
-         */
-        implicitDeps?: {
-            [fileName: string]: string;
-        };
-        /**
-         * Hash of the runtime environment which the task was executed
-         */
-        runtime?: {
-            [input: string]: string;
-        };
-    };
-    /**
-     *
-     * Unix timestamp of when a Batch Task starts
-     **/
-    startTime?: number;
-    /**
-     *
-     * Unix timestamp of when a Batch Task ends
-     **/
-    endTime?: number;
-    /**
-     * Determines if a given task should be cacheable.
-     */
-    cache?: boolean;
-    /**
-     * Determines if a given task should be parallelizable.
-     */
-    parallelism: boolean;
-    /**
-     * This denotes if the task runs continuously
-     */
-    continuous?: boolean;
-}
-/**
- * Graph of Tasks to be executed
- */
-export interface TaskGraph {
-    /**
-     * IDs of Tasks which do not have any dependencies and are thus ready to execute immediately
-     */
-    roots: string[];
-    /**
-     * Map of Task IDs to Tasks
-     */
-    tasks: Record<string, Task>;
-    /**
-     * Map of Task IDs to IDs of tasks which the task depends on
-     */
-    dependencies: Record<string, string[]>;
-    continuousDependencies: Record<string, string[]>;
-}
+export type { Task, TaskGraph, TaskTarget, TaskHashDetails } from '../native';

package/dist/src/hasher/hash-plan-inspector.d.ts

@@ -15,7 +15,7 @@ export declare class HashPlanInspector {
     /**
      * This is a lower level method which will inspect the hash plan for a set of tasks.
      */
-    inspectHashPlan(projectNames: string[], targets: string[], configuration?: string, overrides?: Object, extraTargetDependencies?: TargetDependencies, excludeTaskDependencies?: boolean): Record<string, string[]>;
+    inspectHashPlan(projectNames: string[], targets: string[], configuration?: string, overrides?: Record<string, unknown>, extraTargetDependencies?: TargetDependencies, excludeTaskDependencies?: boolean): Record<string, string[]>;
     /**
      * This inspects tasks involved in the execution of a task, including its dependencies by default.
      * @deprecated Prefer inspectTaskInputs

package/dist/src/native/index.d.ts

@@ -581,26 +581,66 @@ export interface Target {
   parallelism?: boolean
 }
 
+/** A representation of the invocation of an Executor */
 export interface Task {
+  /** Unique ID */
   id: string
+  /** Details about which project, target, and configuration to run. */
   target: TaskTarget
+  /** Overrides for the configured options of the target */
+  overrides: Record<string, unknown>
+  /** The outputs the task may produce */
   outputs: Array<string>
+  /** Root of the project the task belongs to */
   projectRoot?: string
+  /** Hash of the task which is used for caching. */
+  hash?: string
+  /** Details about the composition of the hash */
+  hashDetails?: TaskHashDetails
+  /** Unix timestamp of when a Batch Task starts */
   startTime?: number
+  /** Unix timestamp of when a Batch Task ends */
   endTime?: number
+  /** Determines if a given task should be cacheable. */
+  cache?: boolean
+  /** Determines if a given task should be parallelizable. */
+  parallelism?: boolean
+  /** This denotes if the task runs continuously */
   continuous?: boolean
 }
 
+/** Graph of Tasks to be executed */
 export interface TaskGraph {
+  /** IDs of Tasks which do not have any dependencies and are thus ready to execute immediately */
   roots: Array<string>
+  /** Map of Task IDs to Tasks */
   tasks: Record<string, Task>
+  /** Map of Task IDs to IDs of tasks which the task depends on */
   dependencies: Record<string, Array<string>>
   continuousDependencies: Record<string, Array<string>>
 }
 
+/** Details about the composition of a task's hash */
+export interface TaskHashDetails {
+  /** Command of the task */
+  command: string
+  /** Hashes of inputs used in the hash */
+  nodes: Record<string, string>
+  /** Hashes of implicit dependencies which are included in the hash */
+  implicitDeps?: Record<string, string>
+  /** Hash of the runtime environment which the task was executed */
+  runtime?: Record<string, string>
+}
+
+/**
+ * The result of a completed Task.
+ *
+ * Task timing information (start and end timestamps) is available
+ * on the Task object itself via `Task.startTime` and `Task.endTime`.
+ */
 export interface TaskResult {
   task: Task
-  status: string
+  status: 'success' | 'failure' | 'skipped' | 'stopped' | 'local-cache-kept-existing' | 'local-cache' | 'remote-cache'
   code: number
   terminalOutput?: string
 }
@@ -627,8 +667,11 @@ export declare const enum TaskStatus {
 }
 
 export interface TaskTarget {
+  /** The project for which the task belongs to */
   project: string
+  /** The target name which the task should invoke */
   target: string
+  /** The configuration of the target which the task invokes */
   configuration?: string
 }
 

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

@@ -270,27 +270,45 @@ function stringifyNpmLockfile(graph, rootLockFileContent, packageJson) {
     }
     return JSON.stringify(output, null, 2);
 }
+const WORKSPACE_DEP_TYPES = [
+    'dependencies',
+    'optionalDependencies',
+    'peerDependencies',
+];
 function mapWorkspaceModules(packageJson, rootLockFile, workspaceModules) {
     const output = {};
-    for (const [pkgName, pkgVersion] of Object.entries(packageJson.dependencies ?? {})) {
-        if (workspaceModules.has(pkgName)) {
-            let workspaceModuleDefinition;
-            for (const [depName, depSnapshot] of Object.entries(rootLockFile.packages || rootLockFile.dependencies)) {
-                if (depSnapshot.name === pkgName) {
-                    workspaceModuleDefinition = depSnapshot;
-                    break;
-                }
-            }
-            output[`node_modules/${pkgName}`] = {
-                version: `file:./workspace_modules/${pkgName}`,
-                resolved: `workspace_modules/${pkgName}`,
-                link: true,
-            };
-            output[`workspace_modules/${pkgName}`] = {
-                name: pkgName,
-                version: `0.0.1`,
-                dependencies: workspaceModuleDefinition.dependencies,
-            };
+    const snapshotsByName = new Map();
+    for (const snapshot of Object.values(rootLockFile.packages || rootLockFile.dependencies || {})) {
+        if (snapshot.name)
+            snapshotsByName.set(snapshot.name, snapshot);
+    }
+    // Walk transitive workspace deps so every workspace package
+    // copy-workspace-modules writes to disk has matching lockfile entries.
+    // Without this, `npm ci` errors with "Missing: <pkg> from lock file".
+    const queue = Object.keys(packageJson.dependencies ?? {});
+    const visited = new Set();
+    while (queue.length > 0) {
+        const pkgName = queue.shift();
+        if (visited.has(pkgName) || !workspaceModules.has(pkgName))
+            continue;
+        visited.add(pkgName);
+        const snapshot = snapshotsByName.get(pkgName);
+        output[`node_modules/${pkgName}`] = {
+            version: `file:./workspace_modules/${pkgName}`,
+            resolved: `workspace_modules/${pkgName}`,
+            link: true,
+        };
+        output[`workspace_modules/${pkgName}`] = {
+            name: pkgName,
+            version: `0.0.1`,
+            dependencies: snapshot?.dependencies,
+        };
+        for (const depType of WORKSPACE_DEP_TYPES) {
+            const deps = snapshot?.[depType];
+            if (!deps)
+                continue;
+            for (const depName of Object.keys(deps))
+                queue.push(depName);
         }
     }
     return output;

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

@@ -14,6 +14,11 @@ const project_graph_pruning_1 = require("./project-graph-pruning");
 const path_1 = require("path");
 const get_workspace_packages_from_graph_1 = require("../utils/get-workspace-packages-from-graph");
 const semver_1 = require("semver");
+const WORKSPACE_DEP_TYPES = [
+    'dependencies',
+    'optionalDependencies',
+    'peerDependencies',
+];
 let currentLockFileHash;
 let parsedLockFile;
 function parsePnpmLockFile(lockFileContent, lockFileHash) {
@@ -389,13 +394,55 @@ function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson, workspac
     const { lockfileVersion, packages, importers } = data;
     const { snapshot: rootSnapshot, importers: requiredImporters } = mapRootSnapshot(packageJson, importers, packages, graph, +lockfileVersion, workspaceRoot);
     const snapshots = mapSnapshots(data.packages, graph.externalNodes, +lockfileVersion);
+    const workspaceModules = (0, get_workspace_packages_from_graph_1.getWorkspacePackagesFromGraph)(graph);
+    // Walk transitive workspace deps so every package copy-workspace-modules
+    // writes to disk has a matching importer block. Without this, pnpm errors
+    // with ERR_PNPM_OUTDATED_LOCKFILE on transitive workspace chains.
+    const allRequiredImporters = { ...requiredImporters };
+    const queue = Object.keys(requiredImporters);
+    while (queue.length > 0) {
+        const pkgName = queue.shift();
+        const importer = importers[allRequiredImporters[pkgName]];
+        if (!importer)
+            continue;
+        for (const depType of WORKSPACE_DEP_TYPES) {
+            const deps = importer[depType];
+            if (!deps)
+                continue;
+            for (const depName of Object.keys(deps)) {
+                if (workspaceModules.has(depName) && !allRequiredImporters[depName]) {
+                    allRequiredImporters[depName] =
+                        workspaceModules.get(depName).data.root;
+                    queue.push(depName);
+                }
+            }
+        }
+    }
     const workspaceDependencyImporters = {};
-    for (const [packageName, importerPath] of Object.entries(requiredImporters)) {
+    for (const [packageName, importerPath] of Object.entries(allRequiredImporters)) {
         const baseImporter = importers[importerPath];
-        if (baseImporter) {
-            workspaceDependencyImporters[`workspace_modules/${packageName}`] =
-                baseImporter;
+        if (!baseImporter)
+            continue;
+        const importer = structuredClone(baseImporter);
+        for (const depType of WORKSPACE_DEP_TYPES) {
+            const deps = importer[depType];
+            if (!deps)
+                continue;
+            for (const depName of Object.keys(deps)) {
+                if (!workspaceModules.has(depName))
+                    continue;
+                // All workspace modules are siblings under workspace_modules/, so the
+                // relative path between them is relative(packageName, depName).
+                // Specifier must match the file: ref copy-workspace-modules writes
+                // to the package's package.json — pnpm errors on a mismatch.
+                const rel = (0, path_1.relative)(packageName, depName).split(path_1.sep).join('/');
+                if (!importer.specifiers)
+                    importer.specifiers = {};
+                importer.specifiers[depName] = `file:${rel}`;
+                deps[depName] = `link:${rel}`;
+            }
         }
+        workspaceDependencyImporters[`workspace_modules/${packageName}`] = importer;
     }
     const output = {
         ...data,

package/dist/src/plugins/js/lock-file/project-graph-pruning.js

@@ -115,11 +115,19 @@ function traverseNode(graph, builder, node) {
         builder.addStaticDependency(node.name, dep.target);
     });
 }
-function traverseWorkspaceNode(graph, builder, node) {
+function traverseWorkspaceNode(graph, builder, node, visited = new Set()) {
+    if (visited.has(node.name))
+        return;
+    visited.add(node.name);
     graph.dependencies[node.name]?.forEach((dep) => {
-        const depNode = graph.externalNodes[dep.target];
-        if (depNode) {
-            traverseNode(graph, builder, depNode);
+        const externalDepNode = graph.externalNodes[dep.target];
+        if (externalDepNode) {
+            traverseNode(graph, builder, externalDepNode);
+            return;
+        }
+        const workspaceDepNode = graph.nodes[dep.target];
+        if (workspaceDepNode) {
+            traverseWorkspaceNode(graph, builder, workspaceDepNode, visited);
         }
     });
 }

package/dist/src/plugins/package-json/create-nodes.d.ts

@@ -1,6 +1,7 @@
 import { NxJsonConfiguration } from '../../config/nx-json';
 import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PackageJson } from '../../utils/package-json';
+import { PackageManagerCommands } from '../../utils/package-manager';
 import { CreateNodesV2 } from '../../project-graph/plugins';
 import { PackageJsonConfigurationCache } from '../../../plugins/package-json';
 export declare const createNodesV2: CreateNodesV2;
@@ -12,12 +13,12 @@ type PackageJsonPatterns = {
     negativeLookup: Record<string, boolean>;
 };
 export declare function buildPackageJsonWorkspacesMatcher(patterns: PackageJsonPatterns): (p: any) => boolean;
-export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache, isInPackageManagerWorkspaces: boolean): {
+export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache, isInPackageManagerWorkspaces: boolean, packageManagerCommand: PackageManagerCommands): {
     projects: {
         [x: string]: ProjectConfiguration;
     };
 };
-export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, workspaceRoot: string, packageJsonPath: string, nxJson: NxJsonConfiguration, isInPackageManagerWorkspaces: boolean): ProjectConfiguration & {
+export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, workspaceRoot: string, packageJsonPath: string, nxJson: NxJsonConfiguration, isInPackageManagerWorkspaces: boolean, packageManagerCommand: PackageManagerCommands): ProjectConfiguration & {
     name: string;
 };
 /**

package/dist/src/plugins/package-json/create-nodes.js

@@ -16,6 +16,7 @@ const globs_1 = require("../../utils/globs");
 const logger_1 = require("../../utils/logger");
 const output_1 = require("../../utils/output");
 const package_json_1 = require("../../utils/package-json");
+const package_manager_1 = require("../../utils/package-manager");
 const path_1 = require("../../utils/path");
 const versions_1 = require("../../utils/versions");
 const plugins_1 = require("../../project-graph/plugins");
@@ -38,6 +39,7 @@ exports.createNodesV2 = [
             return projectJsonRoots.has((0, node_path_1.dirname)(packageJsonPath));
         };
         const cache = (0, package_json_2.readPackageJsonConfigurationCache)();
+        const packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(context.workspaceRoot), context.workspaceRoot);
         return (0, plugins_1.createNodesFromFiles)((packageJsonPath, options, context) => {
             const isInPackageManagerWorkspaces = isInPackageJsonWorkspaces(packageJsonPath);
             if (!isInPackageManagerWorkspaces &&
@@ -45,7 +47,7 @@ exports.createNodesV2 = [
                 // Skip if package.json is not part of the package.json workspaces and not next to a project.json.
                 return null;
             }
-            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache, isInPackageManagerWorkspaces);
+            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand);
         }, packageJsons, _, context);
     },
 ];
@@ -111,7 +113,7 @@ function buildPackageJsonWorkspacesMatcher(patterns) {
         !patterns.negativeLookup[p] &&
         patterns.negative.every((negative) => (0, minimatch_1.minimatch)(p, negative));
 }
-function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces) {
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));
     const projectRoot = (0, node_path_1.dirname)(pkgJsonPath);
     const hash = (0, file_hasher_1.hashObject)({
@@ -128,7 +130,7 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackag
             },
         };
     }
-    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces);
+    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces, packageManagerCommand);
     cache.set(hash, project);
     return {
         projects: {
@@ -136,7 +138,7 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackag
         },
     };
 }
-function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson, isInPackageManagerWorkspaces) {
+function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson, isInPackageManagerWorkspaces, packageManagerCommand) {
     const normalizedPath = packageJsonPath.split('\\').join('/');
     const projectRoot = (0, node_path_1.dirname)(normalizedPath);
     const siblingProjectJson = tryReadJson((0, node_path_1.join)(workspaceRoot, projectRoot, 'project.json'));
@@ -161,7 +163,7 @@ function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, pa
         root: projectRoot,
         name,
         ...packageJson.nx,
-        targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson, nxJson, projectRoot, workspaceRoot),
+        targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson, nxJson, projectRoot, workspaceRoot, packageManagerCommand),
         tags: (0, package_json_1.getTagsFromPackageJson)(packageJson),
         metadata: (0, package_json_1.getMetadataFromPackageJson)(packageJson, isInPackageManagerWorkspaces),
     };

package/dist/src/tasks-runner/create-task-graph.d.ts

@@ -16,16 +16,16 @@ export declare class ProcessTasks {
     };
     private readonly allTargetNames;
     constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph);
-    processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Object, excludeTaskDependencies: boolean): string[];
-    processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Object): void;
+    processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Record<string, unknown>, excludeTaskDependencies: boolean): string[];
+    processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Record<string, unknown>): void;
     private processTasksForMultipleProjects;
     private processTasksForSingleProject;
     private processTasksForDependencies;
     private createDummyTask;
-    createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;
+    createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Record<string, unknown>): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
 }
-export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Object, excludeTaskDependencies?: boolean): TaskGraph;
+export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Record<string, unknown>, excludeTaskDependencies?: boolean): TaskGraph;
 export declare function mapTargetDefaultsToDependencies(defaults: TargetDefaults | undefined): TargetDependencies;
 /**
  * This function is used to filter out the dummy tasks from the dependencies

package/dist/src/tasks-runner/life-cycle.d.ts

@@ -1,19 +1,18 @@
 import { Task } from '../config/task-graph';
-import { BatchInfo, BatchStatus, ExternalObject, TaskStatus as NativeTaskStatus } from '../native';
+import { BatchInfo, BatchStatus, ExternalObject, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
 import { TaskStatus } from './tasks-runner';
 /**
- * The result of a completed {@link Task}
+ * The result of a completed {@link Task}.
+ *
+ * Defined as a Rust struct in `packages/nx/src/native/tasks/types.rs` and
+ * exposed to TypeScript via NAPI. Re-exported here so existing imports
+ * keep working.
  *
  * Task timing information (start and end timestamps) is available
  * on the {@link Task} object itself via {@link Task.startTime} and
  * {@link Task.endTime}.
  */
-export interface TaskResult {
-    task: Task;
-    status: TaskStatus;
-    code: number;
-    terminalOutput?: string;
-}
+export type { TaskResult };
 /**
  * A map of {@link TaskResult} keyed by the ID of the completed {@link Task}s
  */

package/dist/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.js

@@ -13,9 +13,10 @@ class InvokeRunnerTerminalOutputLifeCycle {
         output_1.output.log({
             color: 'cyan',
             title: `Running ${this.tasks.length} tasks:`,
-            bodyLines: this.tasks.map((task) => `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
-                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
-                : ''}`),
+            bodyLines: this.tasks.map((task) => {
+                const unparsed = (0, utils_1.getUnparsedOverrideArgs)(task);
+                return `- Task ${task.id} ${unparsed.length > 0 ? `Overrides: ${unparsed.join(' ')}` : ''}`;
+            }),
         });
         output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
     }
@@ -24,9 +25,8 @@ class InvokeRunnerTerminalOutputLifeCycle {
         const taskIds = this.tasks.map((task) => {
             const cached = this.cachedTasks.indexOf(task) !== -1;
             const failed = this.failedTasks.indexOf(task) !== -1;
-            return `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
-                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
-                : ''} ${cached ? 'CACHED' : ''} ${failed ? 'FAILED' : ''}`;
+            const unparsed = (0, utils_1.getUnparsedOverrideArgs)(task);
+            return `- Task ${task.id} ${unparsed.length > 0 ? `Overrides: ${unparsed.join(' ')}` : ''} ${cached ? 'CACHED' : ''} ${failed ? 'FAILED' : ''}`;
         });
         if (this.failedTasks.length === 0) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');

package/dist/src/tasks-runner/utils.d.ts

@@ -50,6 +50,7 @@ export declare function getCustomHasher(task: Task, projects: Record<string, Pro
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
 export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
 export declare function getCliPath(): string;
+export declare function getUnparsedOverrideArgs(task: Task): string[];
 export declare function getPrintableCommandArgsForTask(task: Task): string[];
 export declare function getSerializedArgsForTask(task: Task, isVerbose: boolean): string[];
 export declare function shouldStreamOutput(task: Task, initiatingProject: string | null): boolean;

package/dist/src/tasks-runner/utils.js

@@ -20,6 +20,7 @@ exports.getCustomHasher = getCustomHasher;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
 exports.getCliPath = getCliPath;
+exports.getUnparsedOverrideArgs = getUnparsedOverrideArgs;
 exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
 exports.getSerializedArgsForTask = getSerializedArgsForTask;
 exports.shouldStreamOutput = shouldStreamOutput;
@@ -206,7 +207,7 @@ function transformLegacyOutputs(projectRoot, outputs) {
 function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode, node) {
     const taskTarget = 'id' in taskTargetOrTask ? taskTargetOrTask.target : taskTargetOrTask;
     const overrides = 'id' in taskTargetOrTask ? taskTargetOrTask.overrides : overridesOrNode;
-    node = 'id' in taskTargetOrTask ? overridesOrNode : node;
+    node = ('id' in taskTargetOrTask ? overridesOrNode : node);
     const { target, configuration } = taskTarget;
     const targetConfiguration = node.data.targets[target];
     const options = {
@@ -385,8 +386,12 @@ function calculateReverseDeps(taskGraph) {
 function getCliPath() {
     return require.resolve(`../../bin/run-executor.js`);
 }
+function getUnparsedOverrideArgs(task) {
+    return task.overrides
+        .__overrides_unparsed__;
+}
 function getPrintableCommandArgsForTask(task) {
-    const args = task.overrides['__overrides_unparsed__'];
+    const args = getUnparsedOverrideArgs(task);
     const target = task.target.target.includes(':')
         ? `"${task.target.target}"`
         : task.target.target;

package/dist/src/utils/child-process.js

@@ -13,8 +13,8 @@ const exit_codes_1 = require("./exit-codes");
 function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
     if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
         if (!packageManagerCommand) {
-            const pm = (0, package_manager_1.detectPackageManager)();
-            packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm);
+            const pm = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
+            packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm, workspace_root_1.workspaceRoot);
         }
         return `${packageManagerCommand.exec} nx`;
     }

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

@@ -94,7 +94,7 @@ export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigra
 export declare function buildTargetFromScript(script: string, scripts: Record<string, string>, packageManagerCommand: PackageManagerCommands): TargetConfiguration;
 export declare function getMetadataFromPackageJson(packageJson: PackageJson, isInPackageManagerWorkspaces: boolean): ProjectMetadata;
 export declare function getTagsFromPackageJson(packageJson: PackageJson): string[];
-export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration, projectRoot: string, workspaceRoot: string): Record<string, TargetConfiguration<any>>;
+export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration, projectRoot: string, workspaceRoot: string, packageManagerCommand: PackageManagerCommands): Record<string, TargetConfiguration<any>>;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

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

@@ -67,7 +67,6 @@ function buildTargetFromScript(script, scripts = {}, packageManagerCommand) {
         },
     };
 }
-let packageManagerCommand;
 function getMetadataFromPackageJson(packageJson, isInPackageManagerWorkspaces) {
     const { scripts, nx, description, name, exports, main, version } = packageJson;
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
@@ -95,12 +94,11 @@ function getTagsFromPackageJson(packageJson) {
     }
     return tags;
 }
-function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceRoot) {
+function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceRoot, packageManagerCommand) {
     const { scripts, nx, private: isPrivate } = packageJson ?? {};
     const res = {};
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
     for (const script of includedScripts) {
-        packageManagerCommand ??= (0, package_manager_1.getPackageManagerCommand)();
         res[script] = buildTargetFromScript(script, scripts, packageManagerCommand);
     }
     for (const targetName in nx?.targets) {
@@ -210,11 +208,11 @@ function preparePackageInstallation(pkg, requiredVersion) {
         cleanup: () => { },
     };
     console.log(`Fetching ${pkg}...`);
-    const packageManager = (0, package_manager_1.detectPackageManager)();
+    const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
     const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
     generatePackageManagerFiles(tempDir, packageManager);
-    const preInstallCommand = (0, package_manager_1.getPackageManagerCommand)(packageManager).preInstall;
     const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+    const preInstallCommand = pmCommands.preInstall;
     let addCommand = pmCommands.addDev;
     if (packageManager === 'pnpm') {
         addCommand = 'pnpm add -D'; // we need to ensure that we are not using workspace command

package/dist/src/utils/plugin-cache-utils.d.ts

@@ -21,8 +21,17 @@ interface PluginCacheData<T> {
 export declare class PluginCache<T> {
     private entries;
     private accessOrder;
-    constructor(cachePath: string);
-    constructor(entries?: Record<string, T>, accessOrder?: string[] | Set<string>);
+    private cachePath;
+    /**
+     * Constructs a `PluginCache`. The `cachePath` is the single source of truth
+     * for both reading and writing — `writeToDisk()` writes to it.
+     *
+     * If `entries` is omitted, the cache is loaded from `cachePath` on disk.
+     * If `entries` is provided, those entries are used as the in-memory state
+     * and the on-disk file is not read (useful for tests or for seeding the
+     * cache with known state).
+     */
+    constructor(cachePath: string, entries?: Record<string, T>, accessOrder?: string[] | Set<string>);
     private touch;
     /**
      * Returns the value for `key`, or `undefined` if not present.
@@ -44,7 +53,7 @@ export declare class PluginCache<T> {
      */
     toSerializable(): PluginCacheData<T>;
     /**
-     * Safely writes this cache to disk.
+     * Safely writes this cache to the path it was constructed with.
      *
      * Strategy:
      * 1. Serialize to JSON
@@ -55,7 +64,7 @@ export declare class PluginCache<T> {
      * 3. On total serialization failure (even after eviction),
      *    write an empty cache so the file is valid
      */
-    writeToDisk(cachePath: string): void;
+    writeToDisk(): void;
     /**
      * Evicts the oldest 50% of entries (front of the access-order queue)
      * and returns the remaining entries + accessOrder as a plain object.

package/dist/src/utils/plugin-cache-utils.js

@@ -20,17 +20,27 @@ const logger_1 = require("./logger");
  * least recently used keys.
  */
 class PluginCache {
-    constructor(cachePathOrEntries, accessOrder) {
-        if (typeof cachePathOrEntries === 'string') {
-            const loaded = loadFromDisk(cachePathOrEntries);
-            this.entries = loaded.entries;
-            this.accessOrder = loaded.accessOrder;
-        }
-        else {
-            this.entries = cachePathOrEntries ?? {};
+    /**
+     * Constructs a `PluginCache`. The `cachePath` is the single source of truth
+     * for both reading and writing — `writeToDisk()` writes to it.
+     *
+     * If `entries` is omitted, the cache is loaded from `cachePath` on disk.
+     * If `entries` is provided, those entries are used as the in-memory state
+     * and the on-disk file is not read (useful for tests or for seeding the
+     * cache with known state).
+     */
+    constructor(cachePath, entries, accessOrder) {
+        this.cachePath = cachePath;
+        if (entries !== undefined) {
+            this.entries = entries;
             this.accessOrder =
                 accessOrder instanceof Set ? accessOrder : new Set(accessOrder ?? []);
         }
+        else {
+            const loaded = loadFromDisk(cachePath);
+            this.entries = loaded.entries;
+            this.accessOrder = loaded.accessOrder;
+        }
     }
     touch(key) {
         // Sets are guaranteed to maintain insertion order, so we can delete and re-add to move it to the end.
@@ -73,7 +83,7 @@ class PluginCache {
         };
     }
     /**
-     * Safely writes this cache to disk.
+     * Safely writes this cache to the path it was constructed with.
      *
      * Strategy:
      * 1. Serialize to JSON
@@ -84,8 +94,8 @@ class PluginCache {
      * 3. On total serialization failure (even after eviction),
      *    write an empty cache so the file is valid
      */
-    writeToDisk(cachePath) {
-        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(cachePath), { recursive: true });
+    writeToDisk() {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.cachePath), { recursive: true });
         let content;
         try {
             content = JSON.stringify({
@@ -115,11 +125,11 @@ class PluginCache {
         }
         // Attempt to write the serialized content to disk
         try {
-            (0, node_fs_1.writeFileSync)(cachePath, content);
+            (0, node_fs_1.writeFileSync)(this.cachePath, content);
         }
         catch {
             // Filesystem error — wipe cache so a corrupted file doesn't persist
-            tryRemoveFile(cachePath);
+            tryRemoveFile(this.cachePath);
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.0.0-beta.5",
+  "version": "23.0.0-beta.7",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -171,16 +171,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.0.0-beta.5",
-    "@nx/nx-darwin-x64": "23.0.0-beta.5",
-    "@nx/nx-freebsd-x64": "23.0.0-beta.5",
-    "@nx/nx-linux-arm-gnueabihf": "23.0.0-beta.5",
-    "@nx/nx-linux-arm64-gnu": "23.0.0-beta.5",
-    "@nx/nx-linux-arm64-musl": "23.0.0-beta.5",
-    "@nx/nx-linux-x64-gnu": "23.0.0-beta.5",
-    "@nx/nx-linux-x64-musl": "23.0.0-beta.5",
-    "@nx/nx-win32-arm64-msvc": "23.0.0-beta.5",
-    "@nx/nx-win32-x64-msvc": "23.0.0-beta.5"
+    "@nx/nx-darwin-arm64": "23.0.0-beta.7",
+    "@nx/nx-darwin-x64": "23.0.0-beta.7",
+    "@nx/nx-freebsd-x64": "23.0.0-beta.7",
+    "@nx/nx-linux-arm-gnueabihf": "23.0.0-beta.7",
+    "@nx/nx-linux-arm64-gnu": "23.0.0-beta.7",
+    "@nx/nx-linux-arm64-musl": "23.0.0-beta.7",
+    "@nx/nx-linux-x64-gnu": "23.0.0-beta.7",
+    "@nx/nx-linux-x64-musl": "23.0.0-beta.7",
+    "@nx/nx-win32-arm64-msvc": "23.0.0-beta.7",
+    "@nx/nx-win32-x64-msvc": "23.0.0-beta.7"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",