nx 23.2.0-beta.0 → 23.2.0-beta.10

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -17,6 +17,10 @@ interface WriterArc {
   readonly __brand: unique symbol;
 }
 
+interface MasterArc {
+  readonly __brand: unique symbol;
+}
+
 interface HashInstruction {
   readonly __brand: unique symbol;
 }
@@ -36,7 +40,7 @@ export declare class AppLifeCycle {
   endTasks(taskResults: Array<TaskResult>, metadata: object): void
   endCommand(summary?: PerformanceSummaryPayload | undefined | null): void
   __init(doneCallback: (() => unknown)): void
-  registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[ParserArc, WriterArc]>): void
+  registerRunningTask(taskId: string, ptyHandles: ExternalObject<[ParserArc, WriterArc, MasterArc]>): void
   registerRunningTaskWithEmptyParser(taskId: string): void
   appendTaskOutput(taskId: string, output: string, isPtyOutput: boolean): void
   setTaskStatus(taskId: string, status: TaskStatus): void
@@ -56,7 +60,7 @@ export declare class AppLifeCycle {
 }
 
 export declare class ChildProcess {
-  getParserAndWriter(): ExternalObject<[ParserArc, WriterArc]>
+  getPtyHandles(): ExternalObject<[ParserArc, WriterArc, MasterArc]>
   getPid(): number
   kill(signal?: NodeJS.Signals | number): void
   onExit(callback: (message: string) => void): void
@@ -326,6 +330,7 @@ export interface EventDimensions {
   packageName: string
   packageVersion: string
   duration: string
+  sampleRate: string
   taskCount: string
   projectCount: string
   cachedTaskCount: string
@@ -411,6 +416,16 @@ export declare function getEventDimensions(): EventDimensions
  */
 export declare function getFilesForOutputsBatch(directory: string, entriesBatch: Array<Array<string>>): Array<Array<string>>
 
+/**
+ * The same list, for JavaScript callers that walk a tree rather than the
+ * filesystem - `visitNotIgnoredFiles` - so both sides apply one baseline
+ * instead of maintaining a second copy that drifts.
+ *
+ * The patterns are gitignore-shaped, so they read the same to the `ignore`
+ * crate here and the `ignore` npm package there.
+ */
+export declare function getHardcodedIgnorePatterns(): Array<string>
+
 /**
  * If `workspace_root` is inside a git worktree, returns the main repo root.
  * Returns `None` when already in the main repo (or not in a git repo at all).
@@ -487,14 +502,14 @@ export interface HashInputs {
  * so the caller can set it as an env var for child processes.
  * Used by CLI and daemon.
  */
-export declare function initializeTelemetry(connection: ExternalObject<NxDbConnection>, workspaceId: string, userId: string, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): string
+export declare function initializeTelemetry(connection: ExternalObject<NxDbConnection>, workspaceId: string, userId: string | undefined | null, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): string
 
 /**
  * Initialize telemetry with a pre-fetched session ID.
  * No DB connection — used by plugin workers that inherit the
  * session ID from their parent process via env var.
  */
-export declare function initializeTelemetryWithSessionId(sessionId: string, workspaceId: string, userId: string, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): void
+export declare function initializeTelemetryWithSessionId(sessionId: string, workspaceId: string, userId: string | undefined | null, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): void
 
 export interface InputsInput {
   input: string
@@ -557,6 +572,24 @@ export interface Link {
 
 export declare function logDebug(message: string): void
 
+/**
+ * Checks which `paths` match the given `globs`, using the same glob engine
+ * as the task hasher (`build_glob_set`). Used to statically match
+ * `dependentTasksOutputFiles` globs against candidate paths.
+ */
+export declare function matchGlobPaths(globs: Array<string>, paths: Array<string>): Array<boolean>
+
+/**
+ * Statically checks which `paths` would be captured by the given output
+ * `entries`, without touching the file system. Mirrors `expand_outputs`
+ * semantics: entries match themselves and anything nested under them (so a
+ * directory entry captures its contents), negated (`!`-prefixed) entries
+ * exclude matches from the whole entry set, and a non-empty list with only
+ * negated entries matches everything not excluded. An empty list matches
+ * nothing.
+ */
+export declare function matchOutputPaths(entries: Array<string>, paths: Array<string>): Array<boolean>
+
 /** Combined metadata for groups and processes */
 export interface Metadata {
   /** Group-level metadata */