@depup/nx 23.2.1-depup.7 → 23.3.0-depup.0

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

@@ -130,6 +130,12 @@ export declare function getWorkspaceRegistryUrlForDisplay(pkg: string): string |
 export declare function packageRegistryView(pkg: string, version: string, args: string[], options?: {
     forceNpm?: boolean;
 }): Promise<string>;
+/**
+ * Parses `npm view --json` output. npm 12 wraps the result in an array even
+ * when a single version matches; npm <= 11 and pnpm print the bare value. A
+ * multi-version match (range spec) stays an array.
+ */
+export declare function parseRegistryViewJson<T = unknown>(raw: string): T;
 /**
  * Only `npm pack` supports downloading a tarball of a specified remote
  * package. `yarn` packs the active workspace, `pnpm pack` only packs

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

@@ -15,6 +15,7 @@ exports.resolvePackageVersionUsingRegistry = resolvePackageVersionUsingRegistry;
 exports.resolvePackageVersionUsingInstallation = resolvePackageVersionUsingInstallation;
 exports.getWorkspaceRegistryUrlForDisplay = getWorkspaceRegistryUrlForDisplay;
 exports.packageRegistryView = packageRegistryView;
+exports.parseRegistryViewJson = parseRegistryViewJson;
 exports.packageRegistryPack = packageRegistryPack;
 exports.clearPackageManagerVersionCache = clearPackageManagerVersionCache;
 exports.getPackageWorkspaces = getPackageWorkspaces;
@@ -705,6 +706,15 @@ options) {
         throw redactErrorCause(e);
     }
 }
+/**
+ * Parses `npm view --json` output. npm 12 wraps the result in an array even
+ * when a single version matches; npm <= 11 and pnpm print the bare value. A
+ * multi-version match (range spec) stays an array.
+ */
+function parseRegistryViewJson(raw) {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : parsed;
+}
 /**
  * Only `npm pack` supports downloading a tarball of a specified remote
  * package. `yarn` packs the active workspace, `pnpm pack` only packs

package/dist/src/utils/plugins/plugin-capabilities.js

@@ -63,12 +63,17 @@ async function tryGetModule(packageJson, workspaceRoot) {
             packageJson['nx-migrations'] ??
             packageJson['schematics'] ??
             packageJson['builders']) {
-            const [pluginPromise] = (0, in_process_loader_1.loadNxPlugin)(packageJson.name, workspaceRoot);
-            return await pluginPromise;
+            return await (0, in_process_loader_1.loadNxPlugin)(packageJson.name, workspaceRoot);
         }
         else {
             return {
                 name: packageJson.name,
+                capabilities: () => ({
+                    hasCreateDependencies: false,
+                    hasCreateMetadata: false,
+                    hasPreTasksExecution: false,
+                    hasPostTasksExecution: false,
+                }),
             };
         }
     }

package/dist/src/utils/project-graph-utils.d.ts

@@ -1,6 +1,8 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import type { ProjectConfiguration } from '../config/workspace-json-project-json';
 export declare function projectHasTarget(project: ProjectGraphProjectNode, target: string): boolean;
+/** The projects that define at least one of `targets`. */
+export declare function runnableForTarget(projects: Record<string, ProjectGraphProjectNode>, targets: string[]): Set<string>;
 export declare function projectHasTargetAndConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string): any;
 export declare function getSourceDirOfDependentProjects(projectName: string, projectGraph?: ProjectGraph): [
     projectDirs: string[],

package/dist/src/utils/project-graph-utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectHasTarget = projectHasTarget;
+exports.runnableForTarget = runnableForTarget;
 exports.projectHasTargetAndConfiguration = projectHasTargetAndConfiguration;
 exports.getSourceDirOfDependentProjects = getSourceDirOfDependentProjects;
 exports.findAllProjectNodeDependencies = findAllProjectNodeDependencies;
@@ -13,6 +14,17 @@ function projectHasTarget(project, target) {
         project.data.targets &&
         project.data.targets[target]);
 }
+/** The projects that define at least one of `targets`. */
+function runnableForTarget(projects, targets) {
+    const runnable = new Set();
+    for (const projectName in projects) {
+        const project = projects[projectName];
+        if (targets.some((target) => projectHasTarget(project, target))) {
+            runnable.add(projectName);
+        }
+    }
+    return runnable;
+}
 function projectHasTargetAndConfiguration(project, target, configuration) {
     return (projectHasTarget(project, target) &&
         project.data.targets[target].configurations &&

package/dist/src/utils/provenance.js

@@ -13,6 +13,15 @@ const package_manager_1 = require("./package-manager");
  *
  * Will throw if the package does not have valid provenance.
  */
+/**
+ * A build the publish workflow cuts from master rather than from a tag:
+ * `23.3.0-pr.36841.f66e88b` from a pull request, `23.2.0-canary.20260908-89f02c1`
+ * from the nightly. Each segment is matched with its leading digits so an
+ * ordinary prerelease like `1.0.0-preview.1` does not qualify.
+ */
+function isPublishedFromMaster(version) {
+    return /-pr\.\d+\./.test(version) || /-canary\.\d/.test(version);
+}
 async function ensurePackageHasProvenance(packageName, packageVersion) {
     // this is used for locally released versions without provenance
     // do not set this for other reasons or you might be exposed to security risks
@@ -25,8 +34,8 @@ async function ensurePackageHasProvenance(packageName, packageVersion) {
             '--silent',
         ]);
         const parsed = JSON.parse(result);
-        // `npm view <pkg>@<spec> --json` returns a bare object on npm <= 11 but an
-        // array on npm 12 and pnpm, even for a single resolved version. A version
+        // `npm view <pkg>@<spec> --json` returns a bare object on npm <= 11 and
+        // pnpm but an array on npm 12, even for a single resolved version. A version
         // range matches several versions and the registry lists all of them
         // (including deprecated ones the installer skips), so we cannot tell which
         // one will actually be installed; refuse rather than verify the wrong
@@ -57,8 +66,15 @@ async function ensurePackageHasProvenance(packageName, packageVersion) {
         if (workflowParameters.path !== '.github/workflows/publish.yml') {
             throw new ProvenanceError(packageName, packageVersion, 'Publishing workflow does not match .github/workflows/publish.yml');
         }
-        if (workflowParameters.ref !== `refs/tags/${npmViewResult.version}`) {
-            throw new ProvenanceError(packageName, packageVersion, `Version ref does not match refs/tags/${npmViewResult.version}`);
+        // PR and canary releases are published by this same workflow running on
+        // master, so a tag for them does not exist and never will. Repository,
+        // workflow path and the artifact digest are still checked, so this only
+        // widens which ref of nrwl/nx is allowed to have built it.
+        const allowedRefs = isPublishedFromMaster(npmViewResult.version)
+            ? [`refs/tags/${npmViewResult.version}`, 'refs/heads/master']
+            : [`refs/tags/${npmViewResult.version}`];
+        if (!allowedRefs.includes(workflowParameters.ref)) {
+            throw new ProvenanceError(packageName, packageVersion, `Version ref does not match ${allowedRefs.join(' or ')}`);
         }
         // verify that provenance was generated from the exact same artifact as the one we are installing
         const distSha = Buffer.from(npmViewResult.dist.integrity.replace('sha512-', ''), 'base64').toString('hex');

package/dist/src/utils/serialize-overrides-into-command-line.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeOverridesIntoCommandLine = serializeOverridesIntoCommandLine;
-const flat_1 = require("flat");
 const shell_quoting_1 = require("./shell-quoting");
 function serializeOverridesIntoCommandLine(options) {
     const unparsed = options._ ? [...options._] : [];
@@ -24,9 +23,8 @@ function serializeOption(key, value, unparsed) {
         value.forEach((item) => serializeOption(key, item, unparsed));
     }
     else if (Object.prototype.toString.call(value) === '[object Object]') {
-        const flattened = (0, flat_1.flatten)(value, { safe: true });
-        for (const flattenedKey in flattened) {
-            serializeOption(`${key}.${flattenedKey}`, flattened[flattenedKey], unparsed);
+        for (const nestedKey of Object.keys(value)) {
+            serializeOption(`${key}.${nestedKey}`, value[nestedKey], unparsed);
         }
     }
     else if (typeof value === 'string' &&

package/dist/src/utils/workspace-context.d.ts

@@ -1,5 +1,9 @@
-import type { NxWorkspaceFilesExternals } from '../native';
-export declare function setupWorkspaceContext(workspaceRoot: string): void;
+import type { ChangeBatch, NxWorkspaceFilesExternals, TaskOutputs, WorkspaceContext, WorkspaceContextOptions } from '../native';
+/** The shapes the native watch calls back with, taken from the binding. A
+ * failure arrives as an Error with no batch or events, so both are nullable. */
+export type WorkspaceChangesListener = Parameters<WorkspaceContext['onChanges']>[0];
+export type WatchEventsListener = Parameters<WorkspaceContext['onWatchEvents']>[0];
+export declare function setupWorkspaceContext(workspaceRoot: string, options?: WorkspaceContextOptions): void;
 export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, projectRootMap: Record<string, string>, useDaemonProcess?: boolean): Promise<import("../native").NxWorkspaceFiles>;
 /**
  * Sync method to get files matching globs from workspace context.
@@ -14,8 +18,52 @@ export declare function multiGlobWithWorkspaceContext(workspaceRoot: string, glo
 export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string>;
 export declare function hashMultiGlobWithWorkspaceContext(workspaceRoot: string, globGroups: string[][]): Promise<string[]>;
 export declare function updateContextWithChangedFiles(workspaceRoot: string, createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
-export declare function updateFilesInContext(workspaceRoot: string, updatedFiles: string[], deletedFiles: string[]): Record<string, string>;
+/**
+ * The subset of `paths` the workspace file map holds: what the watch tracks,
+ * with the ignore rules applied.
+ */
+export declare function trackedFilesInContext(workspaceRoot: string, paths: string[]): string[];
+/** Remembers each task's outputs, as given or else as they are on disk now. */
+export declare function recordOutputsInContext(workspaceRoot: string, entries: TaskOutputs[]): void;
+/** Whether each task's outputs are still as last recorded for its hash. */
+export declare function outputsUnchangedInContext(workspaceRoot: string, entries: TaskOutputs[]): boolean[];
+export declare function updateFilesInContext(workspaceRoot: string, updatedFiles: string[], deletedFiles: string[]): ChangeBatch;
 export declare function getAllFileDataInContext(workspaceRoot: string): Promise<import("../native").FileData[]>;
+/**
+ * Listens for the changes a watching context applies: each change reaches the
+ * listeners once, here or in `settleWorkspaceContext`, whichever takes it
+ * first. Any number of listeners may listen. Returns a function that stops
+ * this one.
+ */
+export declare function subscribeToWorkspaceChanges(workspaceRoot: string, listener: WorkspaceChangesListener): () => void;
+/**
+ * Applies every change the watcher has delivered, waiting out the kernel hop,
+ * and takes every change applied and not yet handed out. Empty when the
+ * context is not watching.
+ */
+export declare function settleWorkspaceContext(workspaceRoot: string): ChangeBatch;
+/**
+ * Takes every change applied and not yet handed out, without waiting for the
+ * watcher: for a caller that has just applied changes itself.
+ */
+export declare function takeAppliedWorkspaceChanges(workspaceRoot: string): ChangeBatch;
+export declare function isWatchingWorkspaceContext(): boolean;
+/**
+ * Listens for every event the context's watch delivers, including writes
+ * under ignored directories and the `rescan` marker. Any number of listeners
+ * may listen. Returns a function that stops this one.
+ */
+export declare function subscribeToWatchEvents(workspaceRoot: string, listener: WatchEventsListener): () => void;
+/** Whether a batch carries no change at all. */
+export declare function isEmptyBatch(batch: ChangeBatch): boolean;
+export declare function stopWatchingWorkspaceContext(): void;
 export declare function getFilesInDirectoryUsingContext(workspaceRoot: string, dir: string): Promise<string[]>;
 export declare function updateProjectFiles(projectRootMappings: Record<string, string>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): import("../native").UpdatedWorkspaceFiles;
+/**
+ * Re-walks the host's files so the archive its plugin workers load includes
+ * writes made since the last walk, such as a migration flushing to disk. The
+ * walk is selective and shared through the files lock; one still running is
+ * reused rather than repeated.
+ */
+export declare function refreshWorkspaceContext(workspaceRoot: string): void;
 export declare function resetWorkspaceContext(): void;

package/dist/src/utils/workspace-context.js

@@ -8,10 +8,21 @@ exports.multiGlobWithWorkspaceContext = multiGlobWithWorkspaceContext;
 exports.hashWithWorkspaceContext = hashWithWorkspaceContext;
 exports.hashMultiGlobWithWorkspaceContext = hashMultiGlobWithWorkspaceContext;
 exports.updateContextWithChangedFiles = updateContextWithChangedFiles;
+exports.trackedFilesInContext = trackedFilesInContext;
+exports.recordOutputsInContext = recordOutputsInContext;
+exports.outputsUnchangedInContext = outputsUnchangedInContext;
 exports.updateFilesInContext = updateFilesInContext;
 exports.getAllFileDataInContext = getAllFileDataInContext;
+exports.subscribeToWorkspaceChanges = subscribeToWorkspaceChanges;
+exports.settleWorkspaceContext = settleWorkspaceContext;
+exports.takeAppliedWorkspaceChanges = takeAppliedWorkspaceChanges;
+exports.isWatchingWorkspaceContext = isWatchingWorkspaceContext;
+exports.subscribeToWatchEvents = subscribeToWatchEvents;
+exports.isEmptyBatch = isEmptyBatch;
+exports.stopWatchingWorkspaceContext = stopWatchingWorkspaceContext;
 exports.getFilesInDirectoryUsingContext = getFilesInDirectoryUsingContext;
 exports.updateProjectFiles = updateProjectFiles;
+exports.refreshWorkspaceContext = refreshWorkspaceContext;
 exports.resetWorkspaceContext = resetWorkspaceContext;
 const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("./cache-directory");
@@ -19,16 +30,36 @@ const is_on_daemon_1 = require("../daemon/is-on-daemon");
 const client_1 = require("../daemon/client/client");
 const handle_import_1 = require("./handle-import");
 let workspaceContext;
-function setupWorkspaceContext(workspaceRoot) {
+let filesReady;
+// Survive a reset: the daemon tears its context down and lets the next read
+// recreate it, and that context must watch and report like the one before.
+let contextOptions;
+let contextRoot;
+let contextGeneration = 0;
+const changeListeners = new Set();
+const eventListeners = new Set();
+function setupWorkspaceContext(workspaceRoot, options) {
     const { WorkspaceContext } = require('../native');
     perf_hooks_1.performance.mark('workspace-context');
-    workspaceContext = new WorkspaceContext(workspaceRoot, (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspaceRoot));
+    const cacheDir = (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspaceRoot);
+    // A plugin worker is only asked for files after its host finished walking
+    // and wrote the archive, so it loads that rather than walking again.
+    workspaceContext = global.NX_PLUGIN_WORKER
+        ? WorkspaceContext.fromArchive(workspaceRoot, cacheDir, options)
+        : new WorkspaceContext(workspaceRoot, cacheDir, options);
+    contextOptions = options;
+    contextRoot = workspaceRoot;
+    contextGeneration++;
+    filesReady = undefined;
+    if (options?.watch) {
+        attachSubscribers();
+    }
     perf_hooks_1.performance.mark('workspace-context:end');
     perf_hooks_1.performance.measure('workspace context init', 'workspace-context', 'workspace-context:end');
 }
 async function getNxWorkspaceFilesFromContext(workspaceRoot, projectRootMap, useDaemonProcess = true) {
     if (!useDaemonProcess || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.getWorkspaceFiles(projectRootMap);
     }
     return client_1.daemonClient.getWorkspaceFiles(projectRootMap);
@@ -46,7 +77,7 @@ function globWithWorkspaceContextSync(workspaceRoot, globs, exclude) {
 }
 async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
     if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.glob(globs, exclude);
     }
     else {
@@ -55,21 +86,21 @@ async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
 }
 async function multiGlobWithWorkspaceContext(workspaceRoot, globs, exclude) {
     if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.multiGlob(globs, exclude);
     }
     return client_1.daemonClient.multiGlob(globs, exclude);
 }
 async function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.hashFilesMatchingGlob(globs, exclude);
     }
     return client_1.daemonClient.hashGlob(globs, exclude);
 }
 async function hashMultiGlobWithWorkspaceContext(workspaceRoot, globGroups) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.hashFilesMatchingGlobs(globGroups);
     }
     return client_1.daemonClient.hashMultiGlob(globGroups);
@@ -89,20 +120,116 @@ async function updateContextWithChangedFiles(workspaceRoot, createdFiles, update
         await client_1.daemonClient.updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles);
     }
 }
+/**
+ * The subset of `paths` the workspace file map holds: what the watch tracks,
+ * with the ignore rules applied.
+ */
+function trackedFilesInContext(workspaceRoot, paths) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext?.trackedFiles(paths) ?? [];
+}
+/** Remembers each task's outputs, as given or else as they are on disk now. */
+function recordOutputsInContext(workspaceRoot, entries) {
+    ensureContextAvailable(workspaceRoot);
+    workspaceContext?.recordOutputs(entries);
+}
+/** Whether each task's outputs are still as last recorded for its hash. */
+function outputsUnchangedInContext(workspaceRoot, entries) {
+    ensureContextAvailable(workspaceRoot);
+    return (workspaceContext?.outputsUnchanged(entries) ?? entries.map(() => false));
+}
 function updateFilesInContext(workspaceRoot, updatedFiles, deletedFiles) {
     ensureContextAvailable(workspaceRoot);
     return workspaceContext?.incrementalUpdate(updatedFiles, deletedFiles);
 }
 async function getAllFileDataInContext(workspaceRoot) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.allFileData();
     }
     return client_1.daemonClient.getWorkspaceContextFileData();
 }
+/**
+ * Listens for the changes a watching context applies: each change reaches the
+ * listeners once, here or in `settleWorkspaceContext`, whichever takes it
+ * first. Any number of listeners may listen. Returns a function that stops
+ * this one.
+ */
+function subscribeToWorkspaceChanges(workspaceRoot, listener) {
+    changeListeners.add(listener);
+    ensureContextAvailable(workspaceRoot);
+    attachSubscribers();
+    return () => changeListeners.delete(listener);
+}
+/**
+ * Applies every change the watcher has delivered, waiting out the kernel hop,
+ * and takes every change applied and not yet handed out. Empty when the
+ * context is not watching.
+ */
+function settleWorkspaceContext(workspaceRoot) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext.settle();
+}
+/**
+ * Takes every change applied and not yet handed out, without waiting for the
+ * watcher: for a caller that has just applied changes itself.
+ */
+function takeAppliedWorkspaceChanges(workspaceRoot) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext.takeAppliedChanges();
+}
+function isWatchingWorkspaceContext() {
+    return !!contextOptions?.watch;
+}
+/**
+ * Listens for every event the context's watch delivers, including writes
+ * under ignored directories and the `rescan` marker. Any number of listeners
+ * may listen. Returns a function that stops this one.
+ */
+function subscribeToWatchEvents(workspaceRoot, listener) {
+    eventListeners.add(listener);
+    ensureContextAvailable(workspaceRoot);
+    attachSubscribers();
+    return () => eventListeners.delete(listener);
+}
+/** Whether a batch carries no change at all. */
+function isEmptyBatch(batch) {
+    return (batch.createdFiles.length === 0 &&
+        batch.updatedFiles.length === 0 &&
+        batch.deletedFiles.length === 0);
+}
+/**
+ * The native context takes one subscriber per stream; it fans out here. A
+ * delivery a replaced context had already queued does not reach listeners as
+ * if it came from the current one.
+ */
+function attachSubscribers() {
+    if (!workspaceContext || !contextOptions?.watch)
+        return;
+    const generation = contextGeneration;
+    const current = () => generation === contextGeneration;
+    workspaceContext.onChanges((err, batch) => {
+        if (!current() || (!err && (!batch || isEmptyBatch(batch))))
+            return;
+        for (const listener of changeListeners)
+            listener(err, batch);
+    });
+    workspaceContext.onWatchEvents((err, events) => {
+        if (!current())
+            return;
+        for (const listener of eventListeners)
+            listener(err, events);
+    });
+}
+function stopWatchingWorkspaceContext() {
+    changeListeners.clear();
+    eventListeners.clear();
+    contextOptions = undefined;
+    workspaceContext?.stopWatching();
+}
 async function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
-        ensureContextAvailable(workspaceRoot);
+        await ensureFilesReady(workspaceRoot);
         return workspaceContext.getFilesInDirectory(dir);
     }
     return client_1.daemonClient.getFilesInDirectory(dir);
@@ -110,11 +237,48 @@ async function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
 function updateProjectFiles(projectRootMappings, rustReferences, updatedFiles, deletedFiles) {
     return workspaceContext?.updateProjectFiles(projectRootMappings, rustReferences.projectFiles, rustReferences.globalFiles, updatedFiles, deletedFiles);
 }
+/**
+ * Waits for the walk behind the context without holding the event loop. The
+ * native readers block the calling thread until the files exist, so the async
+ * entry points await this first; a plugin host is then never frozen while a
+ * worker is connecting to it.
+ */
+async function ensureFilesReady(workspaceRoot) {
+    ensureContextAvailable(workspaceRoot);
+    // A binding without `ready` (an older native build, a mocked one) reads
+    // synchronously as before.
+    filesReady ??= workspaceContext.ready?.() ?? Promise.resolve();
+    await filesReady;
+}
+/**
+ * Re-walks the host's files so the archive its plugin workers load includes
+ * writes made since the last walk, such as a migration flushing to disk. The
+ * walk is selective and shared through the files lock; one still running is
+ * reused rather than repeated.
+ */
+function refreshWorkspaceContext(workspaceRoot) {
+    if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || client_1.daemonClient.enabled()) {
+        return;
+    }
+    if (workspaceContext?.workspaceRoot !== workspaceRoot) {
+        setupWorkspaceContext(workspaceRoot);
+        return;
+    }
+    workspaceContext.refresh();
+    filesReady = undefined;
+}
 function ensureContextAvailable(workspaceRoot) {
     if (!workspaceContext || workspaceContext?.workspaceRoot !== workspaceRoot) {
-        setupWorkspaceContext(workspaceRoot);
+        setupWorkspaceContext(workspaceRoot, contextOptions);
     }
 }
 function resetWorkspaceContext() {
+    workspaceContext?.stopWatching?.();
     workspaceContext = undefined;
+    filesReady = undefined;
+    // A watching context is the daemon's only watch; left for the next read to
+    // re-create, output and dotenv events in between would be lost.
+    if (contextOptions?.watch && contextRoot) {
+        setupWorkspaceContext(contextRoot, contextOptions);
+    }
 }