@vzn/vx 0.0.241 → 0.0.242

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.241",
+  "version": "0.0.242",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.241",
-    "@vzn/vx-linux-arm64": "0.0.241",
-    "@vzn/vx-darwin-x64": "0.0.241",
-    "@vzn/vx-darwin-arm64": "0.0.241"
+    "@vzn/vx-linux-x64": "0.0.242",
+    "@vzn/vx-linux-arm64": "0.0.242",
+    "@vzn/vx-darwin-x64": "0.0.242",
+    "@vzn/vx-darwin-arm64": "0.0.242"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/git-inputs.ts

@@ -847,6 +847,11 @@ export interface GitEnumeration {
   trusted: Map<string, string>
   /** Whether the worktree had uncommitted changes; null when `git status` failed. */
   dirty: boolean | null
+  /**
+   * What `git status` listed, workspace-relative: modified, staged or deleted
+   * paths (both sides of a rename) and untracked files. Null when it failed.
+   */
+  changed: readonly string[] | null
   /** Workspace-relative paths whose names are not UTF-8 (`decodeGitZ`). */
   undecodable: readonly string[]
   /** `Date.now()` before the spawns: what `trusted` says is true as of no earlier. */
@@ -1038,7 +1043,39 @@ export async function startGitEnumeration(
   if (parsedStatus !== null && parsedStatus.undecodable.size > 0) {
     undecodable.push(...stripPrefixFromSet(parsedStatus.undecodable, gitPrefix))
   }
-  return { all, trusted, dirty: worktreeDirty, undecodable, startedAtMs }
+  return {
+    all,
+    trusted,
+    dirty: worktreeDirty,
+    changed: dirty === null ? null : [...dirty, ...untracked],
+    undecodable,
+    startedAtMs,
+  }
+}
+
+/** A run's whole-tree enumeration, started on its first ask and shared after. */
+export interface LazyGitEnumeration {
+  start(): Promise<GitEnumeration>
+  /** The enumeration, once something started it. */
+  readonly started: Promise<GitEnumeration> | undefined
+}
+
+export function lazyGitEnumeration(workspaceRoot: string): LazyGitEnumeration {
+  let started: Promise<GitEnumeration> | undefined
+  return {
+    start() {
+      if (started === undefined) {
+        started = startGitEnumeration(workspaceRoot, ['.'])
+        // Its first reader may never await it (a config throws first); the
+        // one that does still sees the error.
+        started.catch(() => {})
+      }
+      return started
+    },
+    get started() {
+      return started
+    },
+  }
 }
 
 /** The partition half of `populateGitFilesCache`: store per-project slices of one enumeration. */

package/src/cache/index.ts

@@ -51,6 +51,8 @@ export {
   gitPathspecs,
   repoRootOf,
   startGitEnumeration,
+  lazyGitEnumeration,
+  type LazyGitEnumeration,
   type GitEnumeration,
 } from './git-inputs.js'
 export { LayeredCache, type RemoteCacheLayer } from './layered-cache.js'

package/src/orchestrator/plugin.ts

@@ -259,6 +259,14 @@ export interface DiscoverContext extends WorkspaceHookContext {
   readonly cacheDir: string
   /** The projects found so far: core's, then earlier plugins'. */
   readonly projects: readonly ProjectMeta[]
+  /**
+   * What `git status` lists in the workspace, workspace-relative: modified,
+   * staged or deleted paths (both sides of a rename) and untracked files;
+   * null outside a git worktree. It is the run's own enumeration, so a
+   * plugin whose answer depends on the worktree (nx()'s graph key) reads it
+   * here instead of walking the tree a second time.
+   */
+  worktreeChanges(): Promise<readonly string[] | null>
 }
 
 export interface NamedProject {

package/src/orchestrator/prepare.ts

@@ -21,7 +21,7 @@ import {
   applyGitEnumeration,
   gitPathspecs,
   startGitEnumeration,
-  type GitEnumeration,
+  lazyGitEnumeration,
 } from '../cache/index.js'
 import {
   buildPackageGraph,
@@ -54,6 +54,7 @@ import {
 } from './plugin-host.js'
 import {
   discoverProjects,
+  gitOfDiscovery,
   loadProjects,
   loadWorkspacePlugins,
   type LoadedProjects,
@@ -176,13 +177,15 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // waits: its pathspecs depend on which projects the configs pull in.
   const unscoped =
     options.projects === undefined && options.tasks.some((spec) => spec.indexOf('#') <= 0)
-  const earlyGit: Promise<GitEnumeration> | undefined = unscoped
-    ? startGitEnumeration(workspaceRoot, ['.'])
-    : undefined
-  // A broken config below throws before this is awaited; the detached
-  // handler keeps that from surfacing as an unhandled rejection (the real
-  // await further down still sees the error).
-  earlyGit?.catch(() => {})
+  // A `discover` hook that reads the worktree (nx()'s graph key) starts the
+  // whole-tree enumeration a scoped run would otherwise scope later, here or
+  // in the CLI's selection pass; the run reuses it instead of walking the
+  // tree twice (G-75).
+  const reused = options.discovered?.root === workspaceRoot ? options.discovered : undefined
+  const git =
+    (reused !== undefined ? gitOfDiscovery(reused.projects) : undefined) ??
+    lazyGitEnumeration(workspaceRoot)
+  if (unscoped) void git.start()
   const workspace = await loadWorkspace(workspaceRoot, reads)
   const { workspaceConfig, plugins } = await loadWorkspacePlugins(workspaceRoot, (m) =>
     log.status(m),
@@ -194,9 +197,9 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     ? path.resolve(options.cwd, options.cacheDir)
     : resolveCacheDir(workspaceRoot, workspaceConfig)
   const projectMetas =
-    options.discovered?.root === workspaceRoot
-      ? options.discovered.projects
-      : await discoverProjects(workspace, plugins, cacheDir, (m) => log.status(m))
+    reused !== undefined
+      ? reused.projects
+      : await discoverProjects(workspace, plugins, cacheDir, (m) => log.status(m), git)
   mark('discover projects')
 
   // SCOPED config loading: configs are programs, and evaluating 1090
@@ -377,7 +380,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       ),
     )
     const projectDirs = [...projects.values()].map((p) => p.dir)
-    const enumeration = await (earlyGit ??
+    const enumeration = await (git.started ??
       startGitEnumeration(
         workspaceRoot,
         gitPathspecs(workspaceRoot, projectDirs, usesWorkspaceInputs),

package/src/orchestrator/projects.ts

@@ -18,7 +18,7 @@ import {
   type Workspace,
 } from '../workspace/index.js'
 import type { WorkspaceConfig } from '../config.js'
-import { Cache } from '../cache/index.js'
+import { Cache, lazyGitEnumeration, type LazyGitEnumeration } from '../cache/index.js'
 import { UserError } from '../util/index.js'
 import {
   buildPackageGraph,
@@ -56,6 +56,17 @@ export async function loadWorkspacePlugins(
   return { workspaceConfig, plugins }
 }
 
+/**
+ * The enumeration a discovery's `discover` hooks shared, by the array it
+ * returned: a run handed that array (`RunOptions.discovered`, the CLI's
+ * `--filter` pass) reuses the walk a hook started instead of a second one.
+ */
+const discoveredGit = new WeakMap<readonly ProjectMeta[], LazyGitEnumeration>()
+
+export function gitOfDiscovery(projects: readonly ProjectMeta[]): LazyGitEnumeration | undefined {
+  return discoveredGit.get(projects)
+}
+
 /**
  * The workspace's projects: core's discovery, then the plugin `discover`
  * stage. With no plugin declaring it, `listProjects` alone.
@@ -65,13 +76,21 @@ export async function discoverProjects(
   plugins: readonly VxPlugin[],
   cacheDir: string,
   warn: (message: string) => void,
+  /** The run's enumeration, which `DiscoverContext.worktreeChanges` reads (and starts). */
+  git: LazyGitEnumeration = lazyGitEnumeration(workspace.root),
 ): Promise<ProjectMeta[]> {
   const projects = await listProjects(workspace)
   if (!hasHook(plugins, 'discover')) return projects
+  discoveredGit.set(projects, git)
+  const worktreeChanges = (): Promise<readonly string[] | null> =>
+    git.start().then(
+      (e) => e.changed,
+      () => null,
+    )
   await applyDiscoverHooks(
     plugins,
     projects,
-    { workspaceRoot: workspace.root, cacheDir, warn },
+    { workspaceRoot: workspace.root, cacheDir, warn, worktreeChanges },
     (named, plugin) => namedProject(workspace, projects, named, plugin.name),
   )
   return projects.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))