nx 23.0.0-beta.2 → 23.0.0-beta.21

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

@@ -52,7 +52,7 @@ export declare class AppLifeCycle {
 export declare class ChildProcess {
   getParserAndWriter(): ExternalObject<[ParserArc, WriterArc]>
   getPid(): number
-  kill(signal?: NodeJS.Signals): void
+  kill(signal?: NodeJS.Signals | number): void
   onExit(callback: (message: string) => void): void
   onOutput(callback: (message: string) => void): void
   cleanup(): void
@@ -206,6 +206,18 @@ export declare class TaskHasher {
   hashPlans(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): Record<string, HashDetails>
 }
 
+export declare class TaskInvocationTracker {
+  constructor(db: ExternalObject<NxDbConnection>, rootPid: number)
+  /** Register a task as invoked. Throws if the task was already registered (loop detected). */
+  registerTask(parentPid: number, taskId: string): void
+  /** Remove a task invocation record after task completes. */
+  unregisterTask(taskId: string): void
+  /** Get all invocations for this root_pid, ordered by creation time. */
+  getInvocationChain(): Array<InvocationRecord>
+  /** Clean up stale invocations older than 1 day (handles PID recycling). */
+  cleanupStale(): void
+}
+
 export declare class Watcher {
   origin: string
   /**
@@ -454,6 +466,11 @@ export declare function installNxConsole(): Promise<boolean>
 
 export declare function installNxConsoleForEditor(editor: SupportedEditor): Promise<boolean>
 
+export interface InvocationRecord {
+  parentPid: number
+  taskId: string
+}
+
 export const IS_WASM: boolean
 
 /**
@@ -472,6 +489,23 @@ export interface JsonInput {
   excludeFields?: Array<string>
 }
 
+/**
+ * Kill a process and all its descendants (fire-and-forget).
+ *
+ * Sends the requested signal but does NOT wait for processes to exit.
+ * Use `killProcessTreeGraceful` when cleanup handlers must run.
+ */
+export declare function killProcessTree(rootPid: number, signal?: string | number | undefined | null): void
+
+/**
+ * Kill a process tree gracefully: signal → wait → SIGKILL.
+ *
+ * Signals leaf processes first, waits for them to exit, then signals
+ * their parents (now leaves). Repeats until the tree is empty or the
+ * grace period expires, then force-kills survivors.
+ */
+export declare function killProcessTreeGraceful(rootPid: number, signal?: string | number | undefined | null, gracePeriodMs?: number | undefined | null): Promise<void>
+
 export declare function logDebug(message: string): void
 
 /** Combined metadata for groups and processes */
@@ -581,26 +615,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 +701,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/native/native-bindings.js

@@ -591,6 +591,7 @@ module.exports.RunningTasksService = nativeBinding.RunningTasksService
 module.exports.RustPseudoTerminal = nativeBinding.RustPseudoTerminal
 module.exports.TaskDetails = nativeBinding.TaskDetails
 module.exports.TaskHasher = nativeBinding.TaskHasher
+module.exports.TaskInvocationTracker = nativeBinding.TaskInvocationTracker
 module.exports.Watcher = nativeBinding.Watcher
 module.exports.WorkspaceContext = nativeBinding.WorkspaceContext
 module.exports.BatchStatus = nativeBinding.BatchStatus
@@ -620,6 +621,8 @@ module.exports.installNxConsoleForEditor = nativeBinding.installNxConsoleForEdit
 module.exports.IS_WASM = nativeBinding.IS_WASM
 module.exports.isAiAgent = nativeBinding.isAiAgent
 module.exports.isEditorInstalled = nativeBinding.isEditorInstalled
+module.exports.killProcessTree = nativeBinding.killProcessTree
+module.exports.killProcessTreeGraceful = nativeBinding.killProcessTreeGraceful
 module.exports.logDebug = nativeBinding.logDebug
 module.exports.parseTaskStatus = nativeBinding.parseTaskStatus
 module.exports.remove = nativeBinding.remove

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/js/utils/packages.js

@@ -8,7 +8,7 @@ function getWorkspacePackagesMetadata(projects) {
     const wildcardEntryPointsToProjectMap = {};
     const packageToProjectMap = {};
     for (const project of Object.values(projects)) {
-        const metadata = 'data' in project ? project.data.metadata : project.metadata;
+        const metadata = ('data' in project ? project.data.metadata : project.metadata);
         if (!metadata?.js) {
             continue;
         }

package/dist/src/plugins/js/utils/register.d.ts

@@ -1,31 +1,120 @@
 import type { TsConfigOptions } from 'ts-node';
 import type { CompilerOptions } from 'typescript';
 /**
- * Optionally, if swc-node and tsconfig-paths are available in the current workspace, apply the require
- * register hooks so that .ts files can be used for writing custom workspace projects.
+ * Force-register an ESM loader (`@swc-node/register/esm` if available, else
+ * `ts-node/esm`) via `Module.register` so dynamic `import()` of TS files
+ * goes through a transpiler.
  *
- * If ts-node and tsconfig-paths are not available, the user can still provide an index.js file in
- * the root of their project and the fundamentals will still work (but
- * workspace path mapping will not, for example).
+ * **IMPORTANT — global side effect:** `Module.register` is one-shot per
+ * process and applies to *every* subsequent ESM resolution in the process.
+ * Calling this trades native Node.js TypeScript stripping for transpiled
+ * loading on the dynamic-import path for the rest of the run. CJS
+ * `require()` is unaffected (different hook), so `.cts` files via require
+ * keep using native strip + swc-node's `Module._extensions` hook.
  *
- * @returns cleanup function
+ * Required for the niche case where an ESM config (`.mts` or `.ts` resolved
+ * as ESM) combines top-level await with TypeScript syntax that native strip
+ * can't handle (`enum`, runtime `namespace`, etc.). TLA forces dynamic
+ * `import()`, which bypasses the CJS hook chain - the only way to intercept
+ * is `Module.register`.
+ *
+ * Idempotent: subsequent calls are no-ops.
+ *
+ * Throws if neither `@swc-node/register` nor `ts-node` is installed.
  */
-export declare function registerTsProject(tsConfigPath: string): () => void;
+export declare function forceRegisterEsmLoader(): void;
 /**
- * Optionally, if swc-node and tsconfig-paths are available in the current workspace, apply the require
- * register hooks so that .ts files can be used for writing custom workspace projects.
+ * Whether Nx will defer to Node's native TypeScript stripping for the next
+ * `.ts` load. Mirrors the gate used by `loadTsFile`/`registerTsProject` so
+ * other registration sites (e.g. plugin transpiler) can stay aligned.
+ */
+export declare function isNativeStripPreferred(): boolean;
+/**
+ * This function registers either ts-node or swc-node to transpile TypeScript files on the fly.
+ * It also registers tsconfig-paths to handle path mapping based on the provided tsconfig.
  *
- * If ts-node and tsconfig-paths are not available, the user can still provide an index.js file in
- * the root of their project and the fundamentals will still work (but
- * workspace path mapping will not, for example).
+ * The TypeScript transpiler registration is done regardless of NX_PREFER_NODE_STRIP_TYPES.
+ * If you want to skip transpiler registration, it is recommended that you check `process.features.typescript`.
  *
  * @returns cleanup function
- * @deprecated This signature will be removed in Nx v19. You should pass the full path to the tsconfig in the first argument.
  */
-export declare function registerTsProject(path: string, configFilename: string): any;
+export declare function registerTsProject(tsConfigPath: string): () => void;
 export declare function getSwcTranspiler(compilerOptions: CompilerOptions): (...args: unknown[]) => unknown;
 export declare function getTsNodeTranspiler(compilerOptions: CompilerOptions, tsNodeOptions?: TsConfigOptions, preferTsNode?: boolean): (...args: unknown[]) => unknown;
 export declare function getTranspiler(compilerOptions: CompilerOptions, tsConfigRaw?: unknown): () => (...args: unknown[]) => unknown;
+/**
+ * Node.js throws this code when native type stripping hits an unsupported
+ * construct (enum, runtime namespace, legacy decorators, import = require,
+ * parameter properties on older Node, etc.).
+ *
+ * Exported for tests.
+ */
+export declare function isNativeTypeStripError(err: unknown): boolean;
+/**
+ * A SyntaxError thrown while parsing a forced-CJS file (`.cts`/`.cjs`) as
+ * CommonJS - typically ESM syntax in a CJS file (e.g. `export default` in
+ * `.cts`). Pre-v23 this worked because swc-node's CJS hook compiled away the
+ * ESM syntax; under native strip swc-node isn't registered, so the file
+ * reaches Node's strict CJS parser. swc-node tolerates ESM syntax in `.cts`
+ * (`register()` forces `module: commonjs` regardless of extension), so
+ * escalating to the swc/ts-node fallback recovers the legacy behavior.
+ */
+export declare function isCjsSyntaxError(err: unknown, filePath: string): boolean;
+/**
+ * A ReferenceError from Node treating a `.ts`/`.mts` file as ESM and the file
+ * relying on a CJS-only global: `require`, `__dirname`, or `__filename`.
+ * Pre-v23 swc-node compiled `.ts` to CJS where these globals exist; under
+ * native strip Node detects ESM via `import`/`export` syntax and these globals
+ * are undefined. Registering swc/ts-node compiles ESM->CJS and restores the
+ * legacy globals.
+ */
+export declare function isRequireInEsmScopeError(err: unknown, filePath: string): boolean;
+export declare function isTsEsmSyntaxError(err: unknown, filePath: string): boolean;
+export declare function isTsEsmNamedExportLinkageError(err: unknown, filePath: string): boolean;
+/**
+ * Load a TypeScript file via `require()`.
+ *
+ * When the runtime exposes native TypeScript stripping
+ * (`process.features.typescript`) and the user hasn't opted out via
+ * `NX_PREFER_NODE_STRIP_TYPES=false`, the file loads directly with no
+ * swc/ts-node and no tsconfig-paths registration. If Node throws on an
+ * unsupported construct (enum, runtime namespace, legacy decorators, etc.),
+ * this registers swc/ts-node + tsconfig-paths and retries - matching the
+ * pre-v23 registration. Set `NX_DISABLE_TSCONFIG_PATHS=true` to skip
+ * tsconfig-paths even on fallback (useful when relying on package manager
+ * workspaces). Set `NX_VERBOSE_LOGGING=true` to log when fallback triggers.
+ *
+ * When native strip is opted out (`NX_PREFER_NODE_STRIP_TYPES=false` or
+ * unsupported Node), uses the legacy `registerTsProject` path.
+ *
+ * `tsConfigPath` is only consulted on the swc/ts-node fallback path (for
+ * compilerOptions) and for tsconfig-paths registration. Native strip ignores
+ * it. When omitted, defaults to the workspace root tsconfig.
+ *
+ * Note on ESM: Node 22.12+ supports `require()` of synchronous ESM by default,
+ * so most ESM `.ts` configs load via this function without issue. Modules
+ * that use top-level await throw `ERR_REQUIRE_ASYNC_MODULE` and must be
+ * loaded with dynamic `import()` instead. `ERR_REQUIRE_ESM` (legacy code)
+ * bubbles unchanged for the rare case it still fires, so async-aware callers
+ * can dispatch to `import()`.
+ *
+ * @returns the loaded module
+ */
+export declare function loadTsFile<T = any>(filePath: string, tsConfigPath?: string): T;
+/**
+ * Plain `require()` with a lazy `tsconfig-paths` fallback. Use for files that
+ * are NOT TypeScript (no transpilation needed) but may still import workspace
+ * packages through TS path aliases (e.g. a `.js` changelog renderer that
+ * `require`s `@my-org/lib`).
+ *
+ * `tsconfig-paths` is only registered after the first `require()` fails with
+ * a module-resolution error, so workspaces that resolve aliases through
+ * package-manager symlinks pay nothing. Set `NX_DISABLE_TSCONFIG_PATHS=true`
+ * to skip the fallback entirely.
+ *
+ * @returns the loaded module
+ */
+export declare function requireWithTsconfigFallback<T = any>(filePath: string, tsConfigPath?: string): T;
 /**
  * Register ts-node or swc-node given a set of compiler options.
  *