@vzn/vx 0.0.417 → 0.0.419

package/package.json

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

package/src/cli/watch-filter.ts

@@ -290,3 +290,35 @@ export function isWorkspaceConfigFile(name: string): boolean {
  * workspace is the one it ignores.
  */
 const FINGERPRINT_FILES: ReadonlySet<string> = new Set(WORKSPACE_FINGERPRINT_FILES)
+
+/**
+ * The files under the workspace git lists, tracked and untracked, ignored
+ * ones aside, and every directory above one (git lists no directory, and
+ * a project moved away whole is one event on its directory): what existed
+ * when watch armed, so a path born and gone since is told from a deletion
+ * (watch-judge.ts). Undefined when git cannot answer: no inventory, every
+ * gone path is a deletion as before.
+ */
+export function gitFiles(workspaceRoot: string): Set<string> | undefined {
+  let proc: ReturnType<typeof Bun.spawnSync>
+  try {
+    proc = Bun.spawnSync({
+      cmd: [executablePath('git'), 'ls-files', '-z', '--cached', '--others', '--exclude-standard'],
+      cwd: workspaceRoot,
+      stdout: 'pipe',
+      stderr: 'ignore',
+    })
+  } catch {
+    return undefined
+  }
+  if (proc.exitCode !== 0) return undefined
+  const files = new Set<string>()
+  for (const p of new TextDecoder().decode(proc.stdout).split('\0')) {
+    if (p.length === 0) continue
+    let abs = path.join(workspaceRoot, p)
+    files.add(abs)
+    for (abs = path.dirname(abs); abs !== workspaceRoot && !files.has(abs); abs = path.dirname(abs))
+      files.add(abs)
+  }
+  return files
+}

package/src/cli/watch-judge.ts

@@ -53,6 +53,8 @@ export interface JudgeContext {
   held(): boolean
   /** Projects whose uncached task may read a git-ignored file. */
   uncached(): ReadonlySet<string>
+  /** The files git listed at the arm; absent when git could not answer. */
+  existedAtArm?: ReadonlySet<string>
 }
 
 export class ChangeJudge {
@@ -108,12 +110,22 @@ export class ChangeJudge {
   // and a first sighting used to pass unconditionally; the path's mtime
   // says which side of the arm it belongs to. A path already gone is a
   // change: a deletion has no date to read.
-  private sameState(abs: string): boolean {
+  // One exception: a path git did not list at the arm, and gone now, was
+  // born and removed since (vim's `4913` write probe, a tool's lock file);
+  // it started a cycle with nothing changed. The blind spot: one born in
+  // the moment between a judgement and that cycle's keys, and gone by the
+  // next judgement, was read and its deletion re-runs nothing. Git lists
+  // no ignored path, so one of those is a deletion as before.
+  private sameState(abs: string, ignored = false): boolean {
     const state = settledState(abs)
     const prev = this.lastState.get(abs)
     this.lastState.set(abs, state)
     if (prev !== undefined) return prev === state
-    return state !== ABSENT && modifiedBefore(abs, this.ctx.armedAt)
+    if (state === ABSENT) {
+      const listed = this.ctx.existedAtArm
+      return !ignored && listed !== undefined && !listed.has(abs)
+    }
+    return modifiedBefore(abs, this.ctx.armedAt)
   }
 
   private writtenDuringLastCycle(abs: string, openWhileHeld = false): boolean {
@@ -158,7 +170,7 @@ export class ChangeJudge {
     let gone: [label: string, abs: string] | undefined
     for (const [p, l] of this.pending) {
       if (ignored.has(p) && !editForUncached(p)) continue
-      if (this.sameState(p) || first !== undefined) continue
+      if (this.sameState(p, ignored.has(p)) || first !== undefined) continue
       if (!fs.existsSync(p)) {
         gone ??= [l, p]
         continue

package/src/cli/watch.ts

@@ -35,6 +35,7 @@ import { type CliLoadOptions, discoverCliProjects, loadCliWorkspace } from './wo
 import {
   isIgnoredWatchPath,
   isWorkspaceConfigFile,
+  gitFiles,
   isWorkspaceFingerprintFile,
   makeRootEventFilter,
   makeWatchIgnore,
@@ -416,12 +417,15 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
 
   /** The instant the watchers go live, on the mtime clock (see `fsClockNow`): a path last modified before it is the initial run's, not an edit. */
   const armedAt = fsClockNow(cacheDir)
+  /** What existed at the arm, so a file born and gone since is no deletion (watch-judge.ts). */
+  const existedAtArm = gitFiles(workspaceRoot)
   /** Which settled paths are changes (watch-judge.ts); `pending` holds what fired since. */
   const changes = new ChangeJudge({
     workspaceRoot,
     armedAt,
     held: () => held !== undefined,
     uncached: () => uncached,
+    ...(existedAtArm !== undefined ? { existedAtArm } : {}),
   })
   /** Per-project arms by directory, so `rearm` can add and drop them. */
   const perProject = new Map<string, WatchHandle>()