nx 23.3.0-beta.4 → 23.3.0-beta.6

package/dist/src/io-snapshots/store.d.ts

@@ -0,0 +1,37 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { IoSnapshotStore, type IoSnapshots } from '../native';
+import { type IoSnapshotCloudOptions, type IoSnapshotEnv } from './config';
+import { type ReadIoSnapshotsResult } from './fetch';
+/** What resolving this run's snapshot set came to. Only a set that resolved carries one. */
+export type IoSnapshotOutcome = {
+    status: 'fetched' | 'cached';
+    snapshots: IoSnapshots;
+} | {
+    status: 'skipped';
+    reason: string;
+    message: string;
+};
+export declare function skippedIoSnapshots(reason: string, message: string): IoSnapshotOutcome;
+/** The set an outcome resolved to, if any. */
+export declare function snapshotsOf(outcome: IoSnapshotOutcome | null): IoSnapshots | undefined;
+/** The snapshot store in this process's workspace database. */
+export declare function getIoSnapshotStore(): IoSnapshotStore;
+/**
+ * Stores a set the Nx Cloud client read for `requestedCommit` and returns its
+ * handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
+ */
+export declare function importIoSnapshots(requestedCommit: string, snapshots: ReadIoSnapshotsResult['snapshots']): IoSnapshots;
+/**
+ * The stored version `importIoSnapshots` returned, reopened by its commit and
+ * `resolution.fetchedAt`, so other processes hash from it without importing
+ * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
+ */
+export declare function openIoSnapshots(commit: string, fetchedAt: number): IoSnapshots | null;
+/**
+ * This run's I/O snapshot set for HEAD, in the process that owns the fetch:
+ * the stored set while it is fresh, otherwise what Nx Cloud reads, imported
+ * into the store. Returns `null` when snapshots are not enabled for this
+ * workspace; never throws.
+ */
+export declare function loadIoSnapshotsForRun(nxJson: NxJsonConfiguration, runnerOptions: IoSnapshotCloudOptions, env?: IoSnapshotEnv): Promise<IoSnapshotOutcome | null>;

package/dist/src/io-snapshots/store.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skippedIoSnapshots = skippedIoSnapshots;
+exports.snapshotsOf = snapshotsOf;
+exports.getIoSnapshotStore = getIoSnapshotStore;
+exports.importIoSnapshots = importIoSnapshots;
+exports.openIoSnapshots = openIoSnapshots;
+exports.loadIoSnapshotsForRun = loadIoSnapshotsForRun;
+const path_1 = require("path");
+const native_1 = require("../native");
+const db_connection_1 = require("../utils/db-connection");
+const git_utils_1 = require("../utils/git-utils");
+const logger_1 = require("../utils/logger");
+const output_1 = require("../utils/output");
+const workspace_root_1 = require("../utils/workspace-root");
+const config_1 = require("./config");
+const fetch_1 = require("./fetch");
+function skippedIoSnapshots(reason, message) {
+    return { status: 'skipped', reason, message };
+}
+/** The set an outcome resolved to, if any. */
+function snapshotsOf(outcome) {
+    return outcome && outcome.status !== 'skipped'
+        ? outcome.snapshots
+        : undefined;
+}
+/**
+ * Younger sets are served without asking Nx Cloud; older ones re-fetch, since
+ * a closer ancestor's recording may have landed.
+ */
+const STORED_SET_MAX_AGE_MS = 60 * 60 * 1000;
+// Reasons that indicate misconfiguration rather than an expected offline
+// state or a client that simply predates snapshots.
+const WARNED_REASONS = new Set([
+    'unauthorized',
+    'invalid-response',
+    'write-failed',
+]);
+/** The snapshot store in this process's workspace database. */
+function getIoSnapshotStore() {
+    return new native_1.IoSnapshotStore((0, db_connection_1.getDbConnection)());
+}
+/**
+ * Stores a set the Nx Cloud client read for `requestedCommit` and returns its
+ * handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
+ */
+function importIoSnapshots(requestedCommit, snapshots) {
+    return getIoSnapshotStore().import({
+        requestedCommit,
+        snapshotsJson: JSON.stringify(snapshots),
+    });
+}
+/**
+ * The stored version `importIoSnapshots` returned, reopened by its commit and
+ * `resolution.fetchedAt`, so other processes hash from it without importing
+ * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
+ */
+function openIoSnapshots(commit, fetchedAt) {
+    return getIoSnapshotStore().getVersion(commit, fetchedAt);
+}
+/**
+ * This run's I/O snapshot set for HEAD, in the process that owns the fetch:
+ * the stored set while it is fresh, otherwise what Nx Cloud reads, imported
+ * into the store. Returns `null` when snapshots are not enabled for this
+ * workspace; never throws.
+ */
+async function loadIoSnapshotsForRun(nxJson, runnerOptions, env = (0, config_1.ioSnapshotEnv)()) {
+    if (!(0, config_1.isIoSnapshotFetchEnabled)(nxJson, runnerOptions, env)) {
+        return null;
+    }
+    const head = (0, git_utils_1.getLatestCommitSha)();
+    if (!head) {
+        return reportIoSnapshotResolution(skippedIoSnapshots('not-a-git-repo', 'Could not resolve HEAD'));
+    }
+    try {
+        const store = getIoSnapshotStore();
+        const cached = () => {
+            const stored = store.get(head, STORED_SET_MAX_AGE_MS);
+            return (stored &&
+                reportIoSnapshotResolution({
+                    status: 'cached',
+                    snapshots: stored,
+                }));
+        };
+        return (cached() ??
+            // Processes that miss together fetch once: the rest find its set.
+            (await withIoSnapshotFetchLock(async () => {
+                const stored = cached();
+                if (stored) {
+                    return stored;
+                }
+                const result = await (0, fetch_1.fetchIoSnapshots)(runnerOptions);
+                return reportIoSnapshotResolution({
+                    status: 'fetched',
+                    snapshots: store.import({
+                        requestedCommit: head,
+                        snapshotsJson: JSON.stringify(result.snapshots),
+                    }),
+                });
+            })));
+    }
+    catch (e) {
+        // No fallback to an older set for this commit: it would hash from a
+        // recording the run could not refresh, and CI can hash natively instead.
+        return reportIoSnapshotResolution(skippedIoSnapshots(reasonFromError(e), errorMessage(e)));
+    }
+}
+/** Runs `fetch` holding a lock beside the workspace database, across processes. */
+async function withIoSnapshotFetchLock(fetch) {
+    if (native_1.IS_WASM) {
+        return fetch();
+    }
+    const lock = new native_1.FileLock((0, path_1.join)((0, db_connection_1.sharedWorkspaceDataDirectory)(workspace_root_1.workspaceRoot), 'io-snapshots.lock'));
+    while (!lock.tryLock()) {
+        await lock.wait();
+    }
+    try {
+        return await fetch();
+    }
+    finally {
+        lock.unlock();
+    }
+}
+const OFFLINE_CODES = new Set([
+    'ECONNABORTED',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'ETIMEDOUT',
+]);
+/** A skip reason from an error's `code`: from the Nx Cloud read or the store. */
+function reasonFromError(e) {
+    const code = e?.code;
+    if (typeof code !== 'string')
+        return 'fetch-failed';
+    if (OFFLINE_CODES.has(code))
+        return 'offline';
+    return code.toLowerCase().replace(/_/g, '-');
+}
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/** Warns or logs what a resolution came to. */
+function reportIoSnapshotResolution(outcome) {
+    if (outcome.status === 'skipped') {
+        if (WARNED_REASONS.has(outcome.reason)) {
+            output_1.output.warn({
+                title: `Nx Cloud I/O snapshots are unavailable (${outcome.reason})`,
+                bodyLines: [outcome.message, 'Tasks will be hashed without them.'],
+            });
+        }
+        else {
+            logger_1.logger.verbose(`Skipping Nx Cloud I/O snapshots (${outcome.reason}): ${outcome.message}`);
+        }
+        return outcome;
+    }
+    const { resolution } = outcome.snapshots;
+    logger_1.logger.verbose(`Nx Cloud I/O snapshots ${outcome.status}: ${resolution.tasks} tasks for ${resolution.requestedCommit.slice(0, 12)}`);
+    return outcome;
+}

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

@@ -96,8 +96,14 @@ export declare class HashPlanInspector {
 
 export declare class HashPlanner {
   constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
-  getPlans(taskIds: Array<string>, taskGraph: TaskGraph): Record<string, string[]>
-  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph): ExternalObject<Record<string, Array<HashInstruction>>>
+  /**
+   * `snapshots` is this run's I/O snapshot set; a task with an eligible
+   * entry hashes its observed reads instead of its declared filesets.
+   * `options` carries the task ids decided in JS, where executors and
+   * target configuration are resolved.
+   */
+  getPlans(taskIds: Array<string>, taskGraph: TaskGraph, snapshots?: IoSnapshots | undefined | null, options?: IoSnapshotEligibilityOptions | undefined | null): Record<string, string[]>
+  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph, snapshots?: IoSnapshots | undefined | null, options?: IoSnapshotEligibilityOptions | undefined | null): ExternalObject<Record<string, Array<HashInstruction>>>
 }
 
 export declare class HttpRemoteCache {
@@ -121,6 +127,43 @@ export declare class ImportResult {
   staticImportExpressions: Array<string>
 }
 
+/**
+ * One stored version of a commit's snapshot set. Handed to the hash planner as-is.
+ * A fresh import holds every entry; a handle reopened from storage reads
+ * them per task as they are asked for and remembers them, so it costs the
+ * tasks it plans rather than the workspace's whole set.
+ */
+export declare class IoSnapshots {
+  get commit(): string
+  get resolution(): IoSnapshotResolution
+}
+
+/**
+ * The workspace database's snapshot sets. Each import is its own version,
+ * keyed by commit and fetch time, so a run that pinned one keeps reading it
+ * while a newer one is imported. Failures throw with a `code` JS maps to a
+ * skip reason: `STORE_UNAVAILABLE`, `INVALID_RESPONSE` or `WRITE_FAILED`.
+ */
+export declare class IoSnapshotStore {
+  constructor(db: ExternalObject<NxDbConnection>)
+  /**
+   * Stores the set the Nx Cloud client read for `requested_commit` as a new
+   * version, and returns it with every entry in hand.
+   */
+  import(options: IoSnapshotImportOptions): IoSnapshots
+  /**
+   * The newest stored set for `commit`, without touching the network;
+   * `null` when none is stored, its row cannot be read, or it was fetched
+   * more than `max_age_ms` ago. Reads only the version's summary row.
+   */
+  get(commit: string, maxAgeMs?: number | undefined | null): IoSnapshots | null
+  /**
+   * Exactly the version of `commit` fetched at `fetched_at`; `null` when it
+   * is not stored or its row cannot be read.
+   */
+  getVersion(commit: string, fetchedAt: number): IoSnapshots | null
+}
+
 export declare class NxCache {
   cacheDirectory: string
   constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
@@ -382,6 +425,73 @@ export declare class WorkspaceContext {
   stopWatching(): void
 }
 
+export interface AffectedOptions {
+  /**
+   * `createNodes` globs of every loaded plugin. Resolved in TypeScript because
+   * `getPlugins` is async and spawns plugin workers.
+   */
+  projectGlobPatterns: Array<string>
+  projectDeletionAffectsAllProjects: boolean
+  workspaceRoot: string
+}
+
+export declare function affectedTasks(projectGraph: ExternalObject<ProjectGraph>, hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, taskGraph: TaskGraph, changedFiles: Array<string>, options: AffectedTasksOptions): AffectedTaskSelection
+
+export interface AffectedTaskSelection {
+  /** Every affected task, sorted. */
+  affected: Array<string>
+  /** `affected` plus everything it depends on, sorted: what a run keeps. */
+  required: Array<string>
+}
+
+export interface AffectedTasksOptions {
+  /**
+   * `createNodes` globs of every loaded plugin. Resolved in TypeScript because
+   * `getPlugins` is async and spawns plugin workers.
+   */
+  projectGlobPatterns: Array<string>
+  workspaceRoot: string
+  /**
+   * Tasks touched whatever their plan says: those of projects a dependency
+   * change names outright (`projectsAffectedByDependencyUpdates`, or a
+   * workspace project the root package.json depends on), and those whose
+   * executor hashes outside its plan. Ids not in the task graph are ignored.
+   */
+  alwaysTouchedTaskIds: Array<string>
+  /**
+   * External node names whose version or integrity moved. A plan carries them
+   * as `External(name)`, so a package is matched the way a path is.
+   */
+  changedExternals: Array<string>
+  /**
+   * Ecosystems whose manifest changed without the change being pinnable to
+   * packages, `npm` for a lock file. Every node of that type counts as
+   * moved, and a node of any other type does not: a pnpm lock file cannot
+   * have moved a Maven artifact.
+   */
+  changedExternalTypes: Array<string>
+  /**
+   * Projects `--exclude` names. Their tasks are dropped from the selection
+   * after the walk, so they still carry a change to the tasks reading them.
+   */
+  excludedProjects: Array<string>
+  /**
+   * The targets the command asked for. The graph also holds what they depend
+   * on, which carries a change but is only ever run as a dependency.
+   */
+  targets: Array<string>
+  /**
+   * Where a field-filtered JSON input's file is read at both ends of the diff.
+   * Unset, as for `--files`, such a file counts as changed whole.
+   */
+  revisions?: FileRevisions
+  /**
+   * The runner's `selectivelyHashTsConfig`: a task hashes only its own
+   * project's tsconfig `paths` entries, rather than none.
+   */
+  selectivelyHashTsConfig: boolean
+}
+
 export interface BatchInfo {
   executorName: string
   taskIds: Array<string>
@@ -453,6 +563,18 @@ export interface DepsOutputsInput {
  */
 export declare function detectAiAgent(): string | null
 
+/**
+ * `jsonDiff(JSON.parse(lhs), JSON.parse(rhs))`, or `null` when either side is
+ * not strict JSON, where `JSON.parse` would throw.
+ */
+export declare function diffJson(lhs: string, rhs: string): Array<JsonChange> | null
+
+/**
+ * Only the projects that own a changed file, one entry per file, in input
+ * order. `nx release` version plans ignore implicit and config-derived touches.
+ */
+export declare function directlyTouchedProjects(projectGraph: ExternalObject<ProjectGraph>, touchedFiles: Array<string>): Array<string>
+
 export interface EnvironmentInput {
   env: string
 }
@@ -512,6 +634,11 @@ export interface ExternalDependenciesInput {
 }
 
 export interface ExternalNode {
+  /**
+   * The ecosystem the node belongs to, `npm` for a package the JS lock-file
+   * parsers found. Optional because a plugin may leave it unset.
+   */
+  type?: string
   packageName?: string
   version: string
   hash?: string
@@ -527,6 +654,15 @@ export interface FileMap {
   nonProjectFiles: Array<FileData>
 }
 
+/**
+ * Where a changed file's two versions are read: `base` from git, `head` from
+ * git or, unset, the working tree.
+ */
+export interface FileRevisions {
+  base: string
+  head?: string
+}
+
 export interface FileSetInput {
   fileset: string
   dependencies?: boolean
@@ -576,12 +712,30 @@ export declare function getFilesForOutputsBatch(directory: string, entriesBatch:
  */
 export declare function getHardcodedIgnorePatterns(): Array<string>
 
+/**
+ * Tasks whose snapshot read another task's outputs: they hash after their
+ * producers ran, because those files only exist then. Needs no project graph,
+ * so the client can call it before the first hashing wave on the daemon path.
+ * Opted-out and custom-hasher tasks are not excluded: deferring a task that
+ * ends up hashed natively only delays its hash, it never changes it.
+ */
+export declare function getIoSnapshotDeferredTaskIds(snapshots: IoSnapshots, taskGraph: TaskGraph): Array<string>
+
+/** The eligibility report, for the run summary. */
+export declare function getIoSnapshotReport(snapshots: IoSnapshots, taskGraph: TaskGraph, options?: IoSnapshotEligibilityOptions | undefined | null): IoSnapshotReport
+
 /**
  * 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).
  */
 export declare function getMainWorktreeRoot(workspaceRoot: string): string | null
 
+/**
+ * Observed outputs per eligible task, for the runner to union into
+ * `task.outputs`.
+ */
+export declare function getObservedIoSnapshotOutputs(snapshots: IoSnapshots, taskGraph: TaskGraph, options?: IoSnapshotEligibilityOptions | undefined | null): Record<string, Array<string>>
+
 export declare function getTransformableOutputs(outputs: Array<string>): Array<string>
 
 /**
@@ -676,6 +830,46 @@ export interface InvocationRecord {
   taskId: string
 }
 
+/**
+ * Why a task (or the whole run) hashes natively; `reason` is rendered by the
+ * run summary.
+ */
+export interface IoSnapshotDiagnostic {
+  reason: string
+  taskId?: string
+  glob?: string
+  message?: string
+}
+
+/** What JS knows about a run's tasks that the eligibility walk needs. */
+export interface IoSnapshotEligibilityOptions {
+  /** Tasks whose executor ships a custom hasher. */
+  customHasherTaskIds?: Array<string>
+}
+
+/** The snapshot set the Nx Cloud client read for HEAD, as JS hands it over. */
+export interface IoSnapshotImportOptions {
+  requestedCommit: string
+  /** `Record<taskId, { commit, inputs, outputs }>` as JSON. */
+  snapshotsJson: string
+}
+
+export interface IoSnapshotReport {
+  /** Task ids hashed from their snapshot. */
+  used: Array<string>
+  /** Subset of `used` whose snapshot also contributes observed outputs. */
+  tasksWithOutputs: Array<string>
+  diagnostics: Array<IoSnapshotDiagnostic>
+  resolution: IoSnapshotResolution
+}
+
+/** What was resolved for a commit; stored beside its entries. */
+export interface IoSnapshotResolution {
+  requestedCommit: string
+  fetchedAt: number
+  tasks: number
+}
+
 export const IS_WASM: boolean
 
 /**
@@ -688,6 +882,18 @@ export declare function isAiAgent(): boolean
 
 export declare function isEditorInstalled(editor: SupportedEditor): Promise<boolean>
 
+/** One entry of `jsonDiff`'s result: `type` is a `JsonDiffType` value. */
+export interface JsonChange {
+  type: string
+  path: Array<string>
+  value: JsonChangeValue
+}
+
+export interface JsonChangeValue {
+  lhs?: any
+  rhs?: any
+}
+
 export interface JsonInput {
   json: string
   fields?: Array<string>
@@ -720,6 +926,15 @@ export interface Link {
   href: string
 }
 
+/**
+ * Runs every locator and returns the touched project names, in locator order,
+ * unsorted overall and with duplicates. Callers dedupe by walking the graph.
+ *
+ * Every branch is deterministic, and must stay so: this order reaches
+ * `result.nodes` insertion order and so `nx show projects --affected`.
+ */
+export declare function locateTouchedProjects(projectGraph: ExternalObject<ProjectGraph>, nxJson: NxJson, touchedFiles: Array<string>, options: AffectedOptions, jsLocators: Array<(files: string[]) => Promise<string[]>>): Promise<Array<string>>
+
 export declare function logDebug(message: string): void
 
 /**
@@ -919,6 +1134,8 @@ export interface Task {
   parallelism?: boolean
   /** This denotes if the task runs continuously */
   continuous?: boolean
+  /** The target's ultracache configuration, if declared */
+  ultracache?: TaskUltracacheConfiguration
 }
 
 /** Graph of Tasks to be executed */
@@ -987,6 +1204,26 @@ export interface TaskTarget {
   configuration?: string
 }
 
+/** Ultracache configuration of a task's target */
+export interface TaskUltracacheConfiguration {
+  /** How this target's tasks participate. Defaults to `on`. */
+  mode?: 'on' | 'warn' | 'error' | 'off'
+  /**
+   * Workspace-relative glob patterns for reads that should be excluded
+   * from ultracache reports. The first path segment cannot contain `*`,
+   * and `?`, `!`, `[`, `]` and extglobs are not supported; anchor the
+   * pattern to a directory instead of leading with `**`.
+   */
+  ignoredReads?: Array<string>
+  /**
+   * Workspace-relative glob patterns for writes that should be excluded
+   * from ultracache reports. The first path segment cannot contain `*`,
+   * and `?`, `!`, `[`, `]` and extglobs are not supported; anchor the
+   * pattern to a directory instead of leading with `**`.
+   */
+  ignoredWrites?: Array<string>
+}
+
 export interface TerminalOutputRecord {
   hash: string
   /**
@@ -1020,6 +1257,31 @@ export interface TuiConfig {
   suppressHints?: boolean
 }
 
+/**
+ * How a target's tasks participate in ultracache. Nx Cloud only: nothing in
+ * the OSS runner records or applies IO, so every mode behaves as `Off` without
+ * it.
+ */
+export declare const enum UltracacheMode {
+  /**
+   * Record IO and let the recording stand in for the target's declared
+   * inputs and outputs. The default.
+   */
+  On = 'on',
+  /**
+   * Record IO and report undeclared reads and writes, but hash and cache
+   * from what the target declared.
+   */
+  Warn = 'warn',
+  /**
+   * Reserved for failing the task on an undeclared read or write. Nothing
+   * enforces that per target yet, so it behaves as `Warn` today.
+   */
+  Error = 'error',
+  /** Record nothing, so no report is produced and nothing is applied. */
+  Off = 'off'
+}
+
 export interface UpdatedWorkspaceFiles {
   fileMap: FileMap
   externalReferences: NxWorkspaceFilesExternals

package/dist/src/native/native-bindings.js

@@ -584,6 +584,8 @@ module.exports.HashPlanner = nativeBinding.HashPlanner
 module.exports.HttpRemoteCache = nativeBinding.HttpRemoteCache
 module.exports.IgnoredIndexReader = nativeBinding.IgnoredIndexReader
 module.exports.ImportResult = nativeBinding.ImportResult
+module.exports.IoSnapshots = nativeBinding.IoSnapshots
+module.exports.IoSnapshotStore = nativeBinding.IoSnapshotStore
 module.exports.NxCache = nativeBinding.NxCache
 module.exports.NxConsolePreferences = nativeBinding.NxConsolePreferences
 module.exports.NxPluginCapabilities = nativeBinding.NxPluginCapabilities
@@ -595,6 +597,7 @@ module.exports.TaskDetails = nativeBinding.TaskDetails
 module.exports.TaskHasher = nativeBinding.TaskHasher
 module.exports.TaskInvocationTracker = nativeBinding.TaskInvocationTracker
 module.exports.WorkspaceContext = nativeBinding.WorkspaceContext
+module.exports.affectedTasks = nativeBinding.affectedTasks
 module.exports.BatchStatus = nativeBinding.BatchStatus
 module.exports.canInstallNxConsole = nativeBinding.canInstallNxConsole
 module.exports.canInstallNxConsoleForEditor = nativeBinding.canInstallNxConsoleForEditor
@@ -602,6 +605,8 @@ module.exports.closeDbConnection = nativeBinding.closeDbConnection
 module.exports.connectToNxDb = nativeBinding.connectToNxDb
 module.exports.copy = nativeBinding.copy
 module.exports.detectAiAgent = nativeBinding.detectAiAgent
+module.exports.diffJson = nativeBinding.diffJson
+module.exports.directlyTouchedProjects = nativeBinding.directlyTouchedProjects
 module.exports.EventType = nativeBinding.EventType
 module.exports.expandFilesInput = nativeBinding.expandFilesInput
 module.exports.expandOutputs = nativeBinding.expandOutputs
@@ -613,7 +618,10 @@ module.exports.getDefaultMaxCacheSize = nativeBinding.getDefaultMaxCacheSize
 module.exports.getEventDimensions = nativeBinding.getEventDimensions
 module.exports.getFilesForOutputsBatch = nativeBinding.getFilesForOutputsBatch
 module.exports.getHardcodedIgnorePatterns = nativeBinding.getHardcodedIgnorePatterns
+module.exports.getIoSnapshotDeferredTaskIds = nativeBinding.getIoSnapshotDeferredTaskIds
+module.exports.getIoSnapshotReport = nativeBinding.getIoSnapshotReport
 module.exports.getMainWorktreeRoot = nativeBinding.getMainWorktreeRoot
+module.exports.getObservedIoSnapshotOutputs = nativeBinding.getObservedIoSnapshotOutputs
 module.exports.getTransformableOutputs = nativeBinding.getTransformableOutputs
 module.exports.GroupType = nativeBinding.GroupType
 module.exports.hashArray = nativeBinding.hashArray
@@ -627,6 +635,7 @@ module.exports.isAiAgent = nativeBinding.isAiAgent
 module.exports.isEditorInstalled = nativeBinding.isEditorInstalled
 module.exports.killProcessTree = nativeBinding.killProcessTree
 module.exports.killProcessTreeGraceful = nativeBinding.killProcessTreeGraceful
+module.exports.locateTouchedProjects = nativeBinding.locateTouchedProjects
 module.exports.logDebug = nativeBinding.logDebug
 module.exports.matchGlobPaths = nativeBinding.matchGlobPaths
 module.exports.matchOutputPaths = nativeBinding.matchOutputPaths
@@ -641,5 +650,6 @@ module.exports.testOnlyTransferFileMap = nativeBinding.testOnlyTransferFileMap
 module.exports.trackEvent = nativeBinding.trackEvent
 module.exports.trackPageView = nativeBinding.trackPageView
 module.exports.transferProjectGraph = nativeBinding.transferProjectGraph
+module.exports.UltracacheMode = nativeBinding.UltracacheMode
 module.exports.validateOutputs = nativeBinding.validateOutputs
 module.exports.WorkspaceErrors = nativeBinding.WorkspaceErrors

package/dist/src/native/transform-objects.d.ts

@@ -1,3 +1,12 @@
 import { ProjectGraph } from '../config/project-graph';
-import { ProjectGraph as RustProjectGraph } from './index';
-export declare function transformProjectGraphForRust(graph: ProjectGraph): RustProjectGraph;
+import { ExternalObject, ProjectGraph as RustProjectGraph } from './index';
+/** The graph copied into Rust, once per graph. */
+export declare function transformProjectGraphForRust(graph: ProjectGraph): ExternalObject<RustProjectGraph>;
+/**
+ * Only what the touched-project locators read: project roots, named inputs and
+ * target inputs. Copying target options and every edge costs several times
+ * what the locators themselves do on a large workspace.
+ */
+export declare function transformProjectGraphForLocators(graph: ProjectGraph): ExternalObject<RustProjectGraph>;
+/** The graph in Rust's shape, still a JS object. Uncached, so safe to edit. */
+export declare function toRustProjectGraph(graph: ProjectGraph): RustProjectGraph;