nx 23.3.0-beta.0 → 23.3.0-beta.2

package/dist/src/hasher/native-task-hasher-impl.js

@@ -8,9 +8,15 @@ const task_io_service_1 = require("../tasks-runner/task-io-service");
 const fileutils_1 = require("../utils/fileutils");
 class NativeTaskHasherImpl {
     constructor(workspaceRoot, nxJson, projectGraph, externals, options) {
+        /**
+         * Plans of the last up-front batch and the task graph they were built for.
+         * The tasks that batch deferred hash from them later without planning again.
+         */
+        this.upfrontPlans = null;
         this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(projectGraph));
         this.allWorkspaceFilesRef = externals.allWorkspaceFiles;
         this.projectFileMapRef = externals.projectFiles;
+        this.ignoredIndexRef = externals.ignoredIndex;
         let tsconfig = {};
         let paths = {};
         let rootTsConfigPath = (0, typescript_1.getRootTsConfigPath)();
@@ -22,17 +28,54 @@ class NativeTaskHasherImpl {
             }
         }
         this.planner = new native_1.HashPlanner(nxJson, this.projectGraphRef);
-        this.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, rootTsConfigPath, options);
+        this.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, rootTsConfigPath, options, this.ignoredIndexRef);
     }
     async hashTask(task, taskGraph, env, cwd, collectInputs) {
         const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs);
         return hashes[0];
     }
     async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
-        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        const envs = perTaskEnvs;
         const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        const hashes = this.hasher.hashPlans(plans, perTaskEnvs, cwd ?? process.cwd(), shouldCollectInputs);
+        const resolvedCwd = cwd ?? process.cwd();
+        const hashes = {};
+        let unplanned = tasks.map((t) => t.id);
+        if (this.upfrontPlans &&
+            unplanned.some((id) => this.upfrontPlans.taskIds.has(id)) &&
+            this.upfrontPlans.fingerprint === taskGraphFingerprint(taskGraph)) {
+            Object.assign(hashes, this.hasher.hashPlansFor(this.upfrontPlans.plans, unplanned, envs, resolvedCwd, shouldCollectInputs));
+            unplanned = unplanned.filter((id) => !(id in hashes));
+        }
+        if (unplanned.length > 0) {
+            const plans = this.planner.getPlansReference(unplanned, taskGraph);
+            Object.assign(hashes, this.hasher.hashPlans(plans, envs, resolvedCwd, shouldCollectInputs));
+        }
         return tasks.map((t) => hashes[t.id]);
     }
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        this.upfrontPlans = {
+            fingerprint: taskGraphFingerprint(taskGraph),
+            taskIds: new Set(tasks.map((t) => t.id)),
+            plans,
+        };
+        const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
+        return this.hasher.hashPlansUpfront(plans, perTaskEnvs, cwd ?? process.cwd(), shouldCollectInputs);
+    }
 }
 exports.NativeTaskHasherImpl = NativeTaskHasherImpl;
+/**
+ * Everything the planner reads from a task graph: each task's target and
+ * outputs, and the graph's edges. The project graph and nx.json are fixed for
+ * the life of a hasher, so equal fingerprints mean equal plans. A run's
+ * results (hash, timings) are left out so hashing one task does not
+ * invalidate the plans of the rest.
+ */
+function taskGraphFingerprint(taskGraph) {
+    const parts = [];
+    for (const id of Object.keys(taskGraph.tasks).sort()) {
+        const task = taskGraph.tasks[id];
+        parts.push(id, task.target.project, task.target.target, task.target.configuration ?? '', (task.outputs ?? []).join(','), (taskGraph.dependencies[id] ?? []).join(','), (taskGraph.continuousDependencies[id] ?? []).join(','));
+    }
+    return (0, native_1.hashArray)(parts);
+}

package/dist/src/hasher/task-hasher.d.ts

@@ -60,6 +60,12 @@ export interface TaskHasher {
      * tasks actually differ.
      */
     hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string): Promise<Hash[]>;
+    /**
+     * Hash the tasks whose hash needs no output of another task, keyed by
+     * task id. A task absent from the result hashes once the tasks it reads
+     * from have run.
+     */
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string): Promise<Record<string, Hash>>;
 }
 export interface TaskHasherImpl {
     /**
@@ -70,6 +76,7 @@ export interface TaskHasherImpl {
      */
     hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, PartialHash>>;
 }
 export type Hasher = TaskHasher;
 export declare class DaemonBasedTaskHasher implements TaskHasher {
@@ -77,6 +84,7 @@ export declare class DaemonBasedTaskHasher implements TaskHasher {
     private readonly runnerOptions;
     constructor(daemonClient: DaemonClient, runnerOptions: any);
     hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>): Promise<Hash[]>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>): Promise<Record<string, Hash>>;
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
 }
 export declare class InProcessTaskHasher implements TaskHasher {
@@ -87,6 +95,7 @@ export declare class InProcessTaskHasher implements TaskHasher {
     private taskHasher;
     constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
     hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, Hash>>;
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash>;
     private createHashDetails;
     private hashCommand;

package/dist/src/hasher/task-hasher.js

@@ -52,6 +52,10 @@ class DaemonBasedTaskHasher {
         const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
         return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), process.cwd(), collectInputs);
     }
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs) {
+        const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
+        return this.daemonClient.hashTasksUpfront(this.runnerOptions, tasks, taskGraph, perTaskEnvs, process.cwd(), collectInputs);
+    }
     async hashTask(task, taskGraph, env) {
         return (await this.hashTasks([task], taskGraph, {
             [task.id]: env ?? process.env,
@@ -73,6 +77,16 @@ class InProcessTaskHasher {
         const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs);
         return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
     }
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+        const hashes = await this.taskHasher.hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd ?? process.cwd(), collectInputs);
+        const result = {};
+        for (const task of tasks) {
+            if (hashes[task.id]) {
+                result[task.id] = this.createHashDetails(task, hashes[task.id]);
+            }
+        }
+        return result;
+    }
     async hashTask(task, taskGraph, env, cwd, collectInputs) {
         const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs);
         return this.createHashDetails(task, res);

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

@@ -75,6 +75,8 @@ export declare class FileLock {
   check(): boolean
   wait(): Promise<void>
   lock(): void
+  /** Takes the lock without blocking; false means another handle holds it. */
+  tryLock(): boolean
 }
 
 export declare class HashPlanInspector {
@@ -104,6 +106,14 @@ export declare class HttpRemoteCache {
   store(hash: string, cacheDirectory: string, terminalOutput: string, code: number): Promise<boolean>
 }
 
+/**
+ * The hasher's handle on an index: lists only after catching up with the
+ * watch behind it.
+ */
+export declare class IgnoredIndexReader {
+
+}
+
 export declare class ImportResult {
   file: string
   sourceProject: string
@@ -122,6 +132,25 @@ export declare class NxCache {
   getBatch(hashes: Array<string>): Array<CachedResult | undefined | null>
   put(hash: string, terminalOutput: string, outputs: Array<string>, code: number): Array<string>
   applyRemoteCacheResults(hash: string, result: CachedResult, outputs?: Array<string> | undefined | null): void
+  /**
+   * Register terminal outputs that were written without a cache entry —
+   * uncacheable tasks, and cacheable ones run with `--skip-nx-cache`.
+   *
+   * Without a row the file is invisible to `remove_old_cache_records`,
+   * which only ever walks hashes it finds in the database, so these files
+   * would accumulate forever. The row carries `is_cache_entry = FALSE` so it
+   * can never be served as a cache hit.
+   *
+   * On conflict `accessed_at` always moves: the reads filter these rows out,
+   * so they would otherwise age from the first write and be collected out
+   * from under a task that is still being run daily. `size` moves only while
+   * the row is still output-only (`NOT is_cache_entry`), so a task rerun with
+   * a longer log stops undercounting against `maxCacheSize`. `is_cache_entry`
+   * is never touched, and a row that already has artifacts keeps the size
+   * `put` recorded, so a rewrite can neither demote a real entry nor replace
+   * its whole-entry size with the terminal output's.
+   */
+  recordTerminalOutputs(records: Array<TerminalOutputRecord>): void
   getTaskOutputsPath(hash: string): string
   getCacheSize(): number
   copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): number
@@ -135,6 +164,16 @@ export declare class NxConsolePreferences {
   setAutoInstallPreference(autoInstall: boolean): void
 }
 
+export declare class NxPluginCapabilities {
+  constructor(db: ExternalObject<NxDbConnection>)
+  record(computedAt: number, capabilities: Array<CachedPluginCapabilities>): void
+  /**
+   * The capabilities recorded with the graph computed at `computed_at`, or
+   * null when what is recorded belongs to another build or nothing is.
+   */
+  get(computedAt: number): Array<CachedPluginCapabilities> | null
+}
+
 export declare class NxTaskHistory {
   constructor(db: ExternalObject<NxDbConnection>)
   recordTaskRuns(taskRuns: Array<TaskRun>): void
@@ -204,7 +243,7 @@ export declare class TaskDetails {
 }
 
 export declare class TaskHasher {
-  constructor(workspaceRoot: string, projectGraph: ExternalObject<ProjectGraph>, projectFileMap: ExternalObject<Record<string, Array<FileData>>>, allWorkspaceFiles: ExternalObject<Array<FileData>>, tsConfig: Buffer, tsConfigPaths: Record<string, Array<string>>, rootTsconfigPath?: string | undefined | null, options?: HasherOptions | undefined | null)
+  constructor(workspaceRoot: string, projectGraph: ExternalObject<ProjectGraph>, projectFileMap: ExternalObject<Record<string, Array<FileData>>>, allWorkspaceFiles: ExternalObject<Array<FileData>>, tsConfig: Buffer, tsConfigPaths: Record<string, Array<string>>, rootTsconfigPath: string | undefined | null, options: HasherOptions | undefined | null, ignoredIndex: ExternalObject<IgnoredIndexReader>)
   /**
    * Hash each task's instructions using the env map keyed by `task.id`.
    * Every task in `hash_plans` must have an entry in `per_task_envs` —
@@ -214,6 +253,21 @@ export declare class TaskHasher {
    * every task id.
    */
   hashPlans(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): Record<string, HashDetails>
+  /**
+   * Like `hash_plans`, but only for the plans the planner did not defer
+   * (`HashPlans::deferred`: a task that reads another task's outputs, or a
+   * disk-backed fileset whose directory contains, or sits inside, an
+   * upstream task's output). The rest are left out and hash once those
+   * tasks have run; their ids are absent from the result and need no entry
+   * in `per_task_envs`.
+   */
+  hashPlansUpfront(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): Record<string, HashDetails>
+  /**
+   * Hashes `task_ids` from plans built earlier, so a task the up-front batch
+   * deferred needs no second planning pass. Ids without a plan are absent
+   * from the result.
+   */
+  hashPlansFor(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, taskIds: Array<string>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): Record<string, HashDetails>
 }
 
 export declare class TaskInvocationTracker {
@@ -228,28 +282,39 @@ export declare class TaskInvocationTracker {
   cleanupStale(): void
 }
 
-export declare class Watcher {
-  origin: string
+export declare class WorkspaceContext {
+  workspaceRoot: string
+  constructor(workspaceRoot: string, cacheDir: string, options?: WorkspaceContextOptions | undefined | null)
   /**
-   * Always applies HARDCODED_IGNORE_PATTERNS plus watcher-specific
-   * patterns (vite/vitest timestamp files), regardless of `use_ignore`.
+   * Loads the files the last walk recorded instead of walking. For a
+   * process whose host already walked, such as a plugin worker.
    */
-  constructor(origin: string, additionalGlobs?: Array<string> | undefined | null, useIgnore?: boolean | undefined | null)
-  watch(callbackTsfn: (err: string | null, events: WatchEvent[]) => void): void
-  stop(): Promise<void>
+  static fromArchive(workspaceRoot: string, cacheDir: string, options?: WorkspaceContextOptions | undefined | null): WorkspaceContext
   /**
-   * Synchronously drains the accumulator. Used by the daemon before
-   * serving a cached project graph so events buffered inside the
-   * IDLE_WINDOW debounce don't go missing. Returns an empty vec if
-   * the watcher hasn't started, the loop has exited, or no events
-   * are buffered.
+   * Bumped once per applied batch that changed anything. Equal values
+   * mean equal files, so a consumer that remembers the value it computed
+   * from can skip recomputing.
    */
-  forceFlushPending(): Array<WatchEvent>
-}
-
-export declare class WorkspaceContext {
-  workspaceRoot: string
-  constructor(workspaceRoot: string, cacheDir: string)
+  changeSeq(): number
+  /**
+   * Walks the workspace again into this context, so it and the archive
+   * include writes made since the last walk. Does nothing while a walk is
+   * in progress. Await `ready()` before reading. What the walk finds
+   * changed goes to the subscriber.
+   *
+   * For a graph built without the daemon, where nothing watches: see
+   * `refreshWorkspaceContext`, called by
+   * `buildProjectGraphAndSourceMapsWithoutDaemon`.
+   */
+  refresh(): boolean
+  /**
+   * Resolves once the files behind this context exist. The readers below
+   * block the calling thread until they do; awaiting this first keeps a
+   * plugin host responsive while its workers are connecting.
+   */
+  ready(): Promise<void>
+  /** On wasm the files are gathered when the context is constructed. */
+  ready(): void
   getWorkspaceFiles(projectRootMap: Record<string, string>): NxWorkspaceFiles
   glob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<string>
   /**
@@ -261,10 +326,60 @@ export declare class WorkspaceContext {
   multiGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<Array<string>>
   hashFilesMatchingGlobs(globGroups: Array<Array<string>>): Array<string>
   hashFilesMatchingGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): string
-  incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): Record<string, string>
+  /**
+   * Applies changes a caller learned of on its own. Waits through a walk in
+   * progress so the answer reflects them. Returns what really changed; the
+   * batch is not published to subscribers.
+   */
+  incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): ChangeBatch
   updateProjectFiles(projectRootMappings: Record<string, string>, projectFiles: ExternalObject<Record<string, Array<FileData>>>, globalFiles: ExternalObject<Array<FileData>>, updatedFiles: Record<string, string>, deletedFiles: Array<string>): UpdatedWorkspaceFiles
   allFileData(): Array<FileData>
+  /**
+   * Recover from dropped watch events: re-walk, and report what changed
+   * against the files this context was holding. The fresh files are
+   * adopted, so the caller only has to feed the returned changes through
+   * its normal recomputation path; subscribers do not see them.
+   */
+  rescanAndDiff(): ChangeBatch
+  /**
+   * The subset of `paths` the file map holds: what the watch tracks, with
+   * the ignore rules applied. A path it does not hold is gitignored, gone,
+   * or not yet reported. Applies what the watch delivered first, as every
+   * other read of the files does, so a write already reported counts.
+   */
+  trackedFiles(paths: Array<string>): Array<string>
   getFilesInDirectory(directory: string): Array<string>
+  /**
+   * Subscribes to the context's changes: the callback is called whenever
+   * something was applied or delivered, with everything not yet taken by
+   * it or by `settle`. Replaces any earlier subscriber.
+   */
+  onChanges(callback: (err: Error | null, batch: ChangeBatch | null) => void): void
+  /**
+   * Subscribes to every event the watch delivers, whether or not it
+   * concerns the files: writes under ignored directories included, and
+   * the `rescan` marker when the kernel dropped events. Replaces any
+   * earlier subscriber. Batches applied to the files are `onChanges`.
+   */
+  onWatchEvents(callback: (err: Error | null, events: WatchEvent[] | null) => void): void
+  /**
+   * Applies everything the watch has delivered, waiting out the kernel hop,
+   * then takes every change applied and not yet taken, one entry per path
+   * at its latest state. The change subscriber takes from the same place,
+   * so no change is handed out twice.
+   */
+  settle(): ChangeBatch
+  /**
+   * Takes every change applied and not yet taken, without waiting for the
+   * watch: for a caller that just applied changes itself, through
+   * `incrementalUpdate` or `rescanAndDiff`.
+   */
+  takeAppliedChanges(): ChangeBatch
+  /**
+   * Stops the watcher and forgets the subscribers. The files stay as they
+   * were; reads no longer pull anything in.
+   */
+  stopWatching(): void
 }
 
 export interface BatchInfo {
@@ -278,6 +393,14 @@ export declare const enum BatchStatus {
   Failure = 'Failure'
 }
 
+export interface CachedPluginCapabilities {
+  createNodesPattern?: string
+  hasCreateDependencies: boolean
+  hasCreateMetadata: boolean
+  hasPreTasksExecution: boolean
+  hasPostTasksExecution: boolean
+}
+
 export interface CachedResult {
   code: number
   terminalOutput?: string
@@ -298,6 +421,20 @@ export declare function canInstallNxConsole(): Promise<boolean>
 
 export declare function canInstallNxConsoleForEditor(editor: SupportedEditor): Promise<boolean>
 
+/**
+ * What one application of changes did to the files. `seq` is the context's
+ * change sequence afterwards; it is unchanged, and the lists empty, when
+ * nothing the batch reported was really different. A path can reach a
+ * consumer in more than one batch (see `settle`): the one with the higher
+ * `seq` holds its later state.
+ */
+export interface ChangeBatch {
+  seq: number
+  createdFiles: Array<FileData>
+  updatedFiles: Array<FileData>
+  deletedFiles: Array<string>
+}
+
 export declare function closeDbConnection(connection: ExternalObject<NxDbConnection>): void
 
 export declare function connectToNxDb(cacheDir: string, dbName?: string | undefined | null): ExternalObject<NxDbConnection>
@@ -357,9 +494,17 @@ export interface EventDimensions {
 export declare const enum EventType {
   delete = 'delete',
   update = 'update',
-  create = 'create'
+  create = 'create',
+  /**
+   * The kernel dropped events (e.g. an inotify queue overflow); per-path
+   * events cannot be trusted complete and consumers must re-walk.
+   */
+  rescan = 'rescan'
 }
 
+/** The files an `includeIgnored` fileset group matches on disk, sorted. */
+export declare function expandFilesInput(workspaceRoot: string, globs: Array<string>): Array<string>
+
 export declare function expandOutputs(directory: string, entries: Array<string>): Array<string>
 
 export interface ExternalDependenciesInput {
@@ -385,6 +530,11 @@ export interface FileMap {
 export interface FileSetInput {
   fileset: string
   dependencies?: boolean
+  /**
+   * Hash the glob straight from disk (so gitignored/generated files count)
+   * instead of the workspace file map.
+   */
+  includeIgnored?: boolean
 }
 
 export declare function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
@@ -624,6 +774,7 @@ export interface NxWorkspaceFilesExternals {
   projectFiles: ExternalObject<Record<string, Array<FileData>>>
   globalFiles: ExternalObject<Array<FileData>>
   allWorkspaceFiles: ExternalObject<Array<FileData>>
+  ignoredIndex: ExternalObject<IgnoredIndexReader>
 }
 
 export declare function parseTaskStatus(stringStatus: string): TaskStatus
@@ -702,6 +853,31 @@ export declare const enum SupportedEditor {
   Unknown = 5
 }
 
+/**
+ * A free function, not a method: `BatchProcess` writes these logs whichever
+ * cache implementation is active, so the sweep must not be reachable only
+ * through the DB-backed one.
+ *
+ * Deletes batch logs by age, then oldest-first while the directory is over
+ * budget.
+ *
+ * No database rows: nothing looks a batch log up by key, so a row would be
+ * write-only bookkeeping that a hard-killed process could skip, orphaning
+ * the file forever. The filesystem cannot drift from itself, and the file
+ * is appended to for the life of its batch, so a size recorded anywhere
+ * else is wrong until that batch ends.
+ *
+ * The budget is separate from `maxCacheSize` on purpose: these are debug
+ * artifacts, and sharing a budget would let one evict a replayable cache
+ * entry — trading a rebuild for a text file.
+ *
+ * The age sweep deletes at `BATCH_OUTPUT_MAX_AGE`; the eviction skips
+ * anything written within `BATCH_OUTPUT_MIN_EVICTION_AGE`. That is
+ * last-write, not creation, so a batch silent through a long quiet phase is
+ * not protected.
+ */
+export declare function sweepBatchOutputs(cachePath: string): void
+
 /** System information (static system-level data) */
 export interface SystemInfo {
   cpuCores: number
@@ -811,6 +987,15 @@ export interface TaskTarget {
   configuration?: string
 }
 
+export interface TerminalOutputRecord {
+  hash: string
+  /**
+   * Byte length of the terminal output written for this hash, so these
+   * files are counted against `maxCacheSize` like any other cache content.
+   */
+  size: number
+}
+
 export declare function testOnlyTransferFileMap(projectFiles: Record<string, Array<FileData>>, nonProjectFiles: Array<FileData>): NxWorkspaceFilesExternals
 
 /** Track an event using the global telemetry instance */
@@ -851,6 +1036,22 @@ export interface WorkingDirectoryInput {
   workingDirectory: string
 }
 
+export interface WorkspaceContextOptions {
+  /**
+   * Keep the files current from a watcher the context owns. Watching
+   * starts before the scan, so nothing written after construction is
+   * missed. Off by default; ignored on wasm, which has no watcher.
+   */
+  watch?: boolean
+  /**
+   * Paths the watch reports even though a hardcoded ignore covers them,
+   * as the daemon does for its own process file. They reach the event
+   * stream only, never the files: the workspace ignore rules still decide
+   * what enters those.
+   */
+  alwaysWatch?: Array<string>
+}
+
 /** Public NAPI error codes that are for Node */
 export declare const enum WorkspaceErrors {
   ParseError = 'ParseError',

package/dist/src/native/index.js

@@ -210,7 +210,7 @@ Module._load = function (request, parent, isMain) {
 
 const indexModulePath = require.resolve('./native-bindings.js');
 delete require.cache[indexModulePath];
-const indexModule = require('./native-bindings.js');
-
-module.exports = indexModule;
+// A direct re-export: node's CommonJS export lexer follows this form, so ESM
+// importers see the named exports. Assigning via a variable hides them.
+module.exports = require('./native-bindings.js');
 Module._load = originalLoad;

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

@@ -582,9 +582,11 @@ module.exports.FileLock = nativeBinding.FileLock
 module.exports.HashPlanInspector = nativeBinding.HashPlanInspector
 module.exports.HashPlanner = nativeBinding.HashPlanner
 module.exports.HttpRemoteCache = nativeBinding.HttpRemoteCache
+module.exports.IgnoredIndexReader = nativeBinding.IgnoredIndexReader
 module.exports.ImportResult = nativeBinding.ImportResult
 module.exports.NxCache = nativeBinding.NxCache
 module.exports.NxConsolePreferences = nativeBinding.NxConsolePreferences
+module.exports.NxPluginCapabilities = nativeBinding.NxPluginCapabilities
 module.exports.NxTaskHistory = nativeBinding.NxTaskHistory
 module.exports.ProcessMetricsCollector = nativeBinding.ProcessMetricsCollector
 module.exports.RunningTasksService = nativeBinding.RunningTasksService
@@ -592,7 +594,6 @@ 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
 module.exports.canInstallNxConsole = nativeBinding.canInstallNxConsole
@@ -602,6 +603,7 @@ module.exports.connectToNxDb = nativeBinding.connectToNxDb
 module.exports.copy = nativeBinding.copy
 module.exports.detectAiAgent = nativeBinding.detectAiAgent
 module.exports.EventType = nativeBinding.EventType
+module.exports.expandFilesInput = nativeBinding.expandFilesInput
 module.exports.expandOutputs = nativeBinding.expandOutputs
 module.exports.findImports = nativeBinding.findImports
 module.exports.flushTelemetry = nativeBinding.flushTelemetry
@@ -633,6 +635,7 @@ module.exports.remove = nativeBinding.remove
 module.exports.restoreTerminal = nativeBinding.restoreTerminal
 module.exports.RunMode = nativeBinding.RunMode
 module.exports.SupportedEditor = nativeBinding.SupportedEditor
+module.exports.sweepBatchOutputs = nativeBinding.sweepBatchOutputs
 module.exports.TaskStatus = nativeBinding.TaskStatus
 module.exports.testOnlyTransferFileMap = nativeBinding.testOnlyTransferFileMap
 module.exports.trackEvent = nativeBinding.trackEvent

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

@@ -663,7 +663,7 @@ function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson, workspac
     }
     output.packages = (0, object_sort_1.sortObjectByKeys)(output.packages);
     stripStandaloneLockfileConfig(output);
-    return (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output);
+    return (0, pnpm_normalizer_1.joinPnpmLockfileDocuments)((0, pnpm_normalizer_1.extractEnvLockfileDocument)(rootLockFileContent), (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output));
 }
 /**
  * Removes settings a standalone, pruned lockfile cannot satisfy on its own.

package/dist/src/plugins/js/lock-file/utils/pnpm-normalizer.d.ts

@@ -15,6 +15,8 @@ export declare function loadPnpmHoistedDepsDefinition(): any;
  */
 export declare function parseAndNormalizePnpmLockfile(content: string): Lockfile;
 export declare function extractMainLockfileDocument(content: string): string;
+export declare function extractEnvLockfileDocument(content: string): string | null;
+export declare function joinPnpmLockfileDocuments(envDocument: string | null, mainDocument: string): string;
 /**
  * Mapping and writing logic from pnpm lockfile `write` function
  */

package/dist/src/plugins/js/lock-file/utils/pnpm-normalizer.js

@@ -9,6 +9,8 @@ exports.usesLeadingDash = usesLeadingDash;
 exports.loadPnpmHoistedDepsDefinition = loadPnpmHoistedDepsDefinition;
 exports.parseAndNormalizePnpmLockfile = parseAndNormalizePnpmLockfile;
 exports.extractMainLockfileDocument = extractMainLockfileDocument;
+exports.extractEnvLockfileDocument = extractEnvLockfileDocument;
+exports.joinPnpmLockfileDocuments = joinPnpmLockfileDocuments;
 exports.stringifyToPnpmYaml = stringifyToPnpmYaml;
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
@@ -68,6 +70,26 @@ function extractMainLockfileDocument(content) {
     }
     return content.slice(separatorIndex + YAML_DOCUMENT_SEPARATOR.length);
 }
+// The package-manager document (`packageManagerDependencies`) must ship with a
+// pruned lockfile whenever the pruned manifest keeps `packageManager`: pnpm
+// refuses a frozen install when the pin is not recorded in the lockfile.
+function extractEnvLockfileDocument(content) {
+    content = content.replace(/\r\n/g, '\n');
+    if (!content.startsWith(YAML_DOCUMENT_START)) {
+        return null;
+    }
+    const separatorIndex = content.indexOf(YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START.length);
+    if (separatorIndex === -1) {
+        return null;
+    }
+    return content.slice(YAML_DOCUMENT_START.length, separatorIndex);
+}
+function joinPnpmLockfileDocuments(envDocument, mainDocument) {
+    if (envDocument === null) {
+        return mainDocument;
+    }
+    return `${YAML_DOCUMENT_START}${envDocument}${YAML_DOCUMENT_SEPARATOR}${mainDocument}`;
+}
 // https://github.com/pnpm/pnpm/blob/50e37072f42bcca6d393a74bed29f7f0e029805d/lockfile/lockfile-file/src/write.ts#L22
 const LOCKFILE_YAML_FORMAT = {
     blankLines: true,

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

@@ -24,6 +24,7 @@ exports.registerTsConfigPaths = registerTsConfigPaths;
 exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;
 const path_1 = require("path");
 const fs_1 = require("fs");
+const fileutils_1 = require("../../../utils/fileutils");
 const logger_1 = require("../../../utils/logger");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const typescript_1 = require("./typescript");
@@ -1208,7 +1209,7 @@ function resolvePathsBaseUrl(tsconfigPath) {
         const absolute = (0, path_1.resolve)(queue.shift());
         const dir = (0, path_1.dirname)(absolute);
         try {
-            const raw = JSON.parse((0, fs_1.readFileSync)(absolute, 'utf-8'));
+            const raw = (0, fileutils_1.readJsonFile)(absolute);
             chain.push({ dir, raw });
             const exts = raw.extends
                 ? Array.isArray(raw.extends)