@vzn/vx 0.0.651 → 0.0.653

package/src/cli/watch-fs.ts

@@ -30,8 +30,6 @@ export const WATCH_PROBE = '.vx-watch-probe'
 
 /** How long a watcher gets to report its own probe before the loop goes on without proof. */
 export const WATCH_PROBE_TIMEOUT_MS = 2_000
-/** The file `fsClockNow` writes and removes, under the cache dir the watchers ignore. */
-const WATCH_CLOCK_STAMP = '.vx-watch-clock'
 
 /** Anything the loop needs to shut down at exit. */
 export interface WatchHandle {
@@ -104,20 +102,19 @@ export function pollWatcher(
         if (e.name === WATCH_PROBE) continue
         const childRel = rel === '' ? e.name : `${rel}/${e.name}`
         if (e.isDirectory()) {
-          if (recursive) {
-            if (!skipDir(childRel)) walk(path.join(abs, e.name), childRel)
-          } else {
-            // A non-recursive arm is there for a name coming or going (a
-            // project's parent hears the project made again), as the OS
-            // watcher reports it: by the directory's identity, not its
-            // times, which every write inside moves.
-            try {
-              const st = fs.statSync(path.join(abs, e.name))
-              current.set(childRel, `dir:${st.dev}:${st.ino}:${st.birthtimeMs}`)
-            } catch {
-              // raced with a delete; the next scan settles it
-            }
+          if (recursive && skipDir(childRel)) continue
+          // A directory is sampled for a name coming or going (a project's
+          // parent hears the project made again, one moved in names its
+          // files, whose times predate the arm), as the OS watcher reports
+          // it: by its identity, not its times, which every write inside
+          // moves.
+          try {
+            const st = fs.statSync(path.join(abs, e.name))
+            current.set(childRel, `dir:${st.dev}:${st.ino}:${st.birthtimeMs}`)
+          } catch {
+            continue // raced with a delete; the next scan settles it
           }
+          if (recursive) walk(path.join(abs, e.name), childRel)
           continue
         }
         // A link is an input as its target string (watch-judge.ts), so that
@@ -184,6 +181,8 @@ export function armWatcher(
   recursive: boolean,
   onEvent: (filename: string) => void,
   timeoutMs = WATCH_PROBE_TIMEOUT_MS,
+  /** The poller's `skipDir`, asked on Linux of a directory under `node_modules` only. */
+  skipDir: (rel: string) => boolean = (rel) => isIgnoredDir(rel.split('/')),
 ): ArmedWatcher {
   let markReady: (ok: boolean) => void = () => {}
   let arrived = false
@@ -211,7 +210,7 @@ export function armWatcher(
   }
   const watcher: WatchHandle =
     recursive && process.platform === 'linux'
-      ? treeWatcher(dir, listener)
+      ? treeWatcher(dir, listener, skipDir)
       : fs.watch(dir, { recursive, persistent: true }, (_event, filename) => listener(filename))
   const probe = path.join(dir, WATCH_PROBE)
   const ready = (async (): Promise<boolean> => {
@@ -220,7 +219,7 @@ export function armWatcher(
     // measured 2026-09-03, with every delivered event under 60 ms). So it is
     // re-written on a short backoff until its event arrives — the first write
     // after the stream goes live is the one that proves it.
-    const deadline = Date.now() + timeoutMs
+    const deadline = performance.now() + timeoutMs
     let ok = false
     let step = 50
     while (!ok) {
@@ -229,7 +228,7 @@ export function armWatcher(
       } catch {
         break // an unwritable dir gets no proof; the watcher is kept
       }
-      const remaining = deadline - Date.now()
+      const remaining = deadline - performance.now()
       if (remaining <= 0) {
         // The write itself can outlast the budget (a loaded macOS runner:
         // 261 ms against 100, E-87), and the loop has not yielded yet: let
@@ -267,8 +266,19 @@ export function armWatcher(
  * inotify watch follows the inode and would report the old name. The
  * arming walk throws at the watch limit, so the pool's fallback still
  * applies; a subdirectory that vanished mid-walk is simply not watched.
+ * A `node_modules` is entered where `skipDir` keeps it: an input names a
+ * path there, or git tracks a file there (watch-filter.ts).
  */
-function treeWatcher(root: string, listener: (filename: string) => void): WatchHandle {
+function treeWatcher(
+  root: string,
+  listener: (filename: string) => void,
+  skipDir: (rel: string) => boolean,
+): WatchHandle {
+  const skips = (rel: string): boolean => {
+    const segments = rel.split('/')
+    if (isIgnoredDir(segments) && segments.at(-1) !== 'node_modules') return true
+    return segments.includes('node_modules') && skipDir(rel)
+  }
   const watchers = new Map<string, fs.FSWatcher>()
   // Which directory each watch holds: inotify follows the inode, so a name
   // removed and made again before its event is handled stats as a
@@ -300,7 +310,7 @@ function treeWatcher(root: string, listener: (filename: string) => void): WatchH
         if (name == null || typeof name !== 'string' || name === '' || name === '.') return
         const child = rel === '' ? name : `${rel}/${name}`
         listener(child)
-        if (isIgnoredDir(child.split('/'))) return
+        if (skips(child)) return
         let st: fs.Stats
         try {
           st = fs.statSync(path.join(abs, name))
@@ -347,7 +357,7 @@ function treeWatcher(root: string, listener: (filename: string) => void): WatchH
     for (const e of entries) {
       const child = rel === '' ? e.name : `${rel}/${e.name}`
       if (e.isDirectory()) {
-        if (!isIgnoredDir(child.split('/'))) watchDir(child, report)
+        if (!skips(child)) watchDir(child, report)
       } else if (report) listener(child)
     }
   }
@@ -384,31 +394,6 @@ export function modifiedBefore(abs: string, t: number): boolean {
   }
 }
 
-/**
- * "Now" as the filesystem will stamp the next write, not as `Date.now()`
- * reads it. A file's mtime comes from the kernel's coarse clock, which
- * runs up to a tick behind the fine clock `Date.now()` reads — measured
- * on the Linux bench box 2026-09-11: 2 of 3,000 tight writes carried an
- * mtime 5.8 ms EARLIER than a `Date.now()` taken before the write, and
- * more under CPU load, where the tick is skipped. An `armedAt` from the
- * fine clock then judged an edit made right after the ready line as
- * "modified before the arm" and dropped it (the watch e2e flake, three
- * shard runs that day; traced: raw event, trigger, `same=true`). A stamp
- * read off a file written here is on the mtime clock itself, and every
- * later write's mtime is at or after it.
- */
-export function fsClockNow(dir: string): number {
-  const stamp = path.join(dir, WATCH_CLOCK_STAMP)
-  try {
-    fs.writeFileSync(stamp, '')
-    const at = fs.statSync(stamp).mtimeMs
-    fs.unlinkSync(stamp)
-    return at
-  } catch {
-    return Date.now()
-  }
-}
-
 /** A handle that watches nothing: a slot a drop emptied, an arm not made. */
 export const CLOSED: WatchHandle = { close() {} }
 
@@ -460,7 +445,9 @@ export class WatcherPool {
     }
     let armed: ArmedWatcher
     try {
-      armed = armWatcher(dir, recursive, onEvent)
+      armed = armWatcher(dir, recursive, onEvent, WATCH_PROBE_TIMEOUT_MS, (rel) =>
+        this.skip(dir, rel),
+      )
     } catch (err) {
       // The OS's watch limit, not the directory: the loop said "watching"
       // and never fired. The poller needs no watch slot.

package/src/cli/watch-judge.ts

@@ -4,13 +4,16 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import { filesBehind } from '../cache/index.js'
+import { FILE_HASH_RACY_MS, filesBehind, racyWindowMs } from '../cache/index.js'
+import { commandWindows, type CommandWindows } from '../orchestrator/index.js'
 import { printable, xxh3 } from '../util/index.js'
 import * as ui from '../ui/index.js'
 import { gitIgnored, gitSpeller } from './watch-filter.js'
 import { modifiedBefore } from './watch-fs.js'
 
 const ABSENT = -1n
+/** A state no judgement saw (`unseen`): equal to none, since a digest is never negative. */
+const UNSEEN = -2n
 /** `settledState` of a directory with no entries. */
 const EMPTY_DIR = xxh3(Buffer.from(''))
 
@@ -108,6 +111,8 @@ export interface JudgeContext {
   awaited?(abs: string): boolean
   /** The files git listed at the arm; absent when git could not answer. */
   existedAtArm?: ReadonlySet<string>
+  /** "Now" on the mtime clock (`fsClockNow`); `Date.now()` when absent. */
+  clock?(): number
   /** The files git tracked at the arm; absent when git could not answer. */
   trackedAtArm?: ReadonlySet<string>
 }
@@ -128,6 +133,12 @@ export class ChangeJudge {
   changed: readonly string[] = []
   /** The last cycle's window, its start on the mtime clock (`fsClockNow`); a write inside it is the run's own. */
   lastCycle: { start: number; end: number } | undefined
+  /**
+   * The cycle the last change-finding judgement started: from that
+   * judgement on the mtime clock, until the loop sets `to` when its run
+   * ends, with the run's command windows (`RunOptions.commandWindows`).
+   */
+  cycle: { from: number; to: number; windows: CommandWindows } | undefined
   // Declared outputs are ignored by PATH above. A task with no `cache`
   // block declares none and still writes into its project, and the
   // watcher sees the write: run 1 writes dist/x, the event re-runs, run 2
@@ -169,6 +180,52 @@ export class ChangeJudge {
     if (!this.lastState.has(abs)) this.lastState.set(abs, settledState(abs))
   }
 
+  /**
+   * An event on `abs`. A write that lands after the judgement that started
+   * a cycle and before its run ends, where no command of the run may write
+   * (`CommandWindows.writerDuring`) and no server the loop holds may have,
+   * is the user's: the run may have keyed its bytes, so the path is a
+   * change at its next judgement whatever it settles to. Judged against
+   * the state that judgement recorded, an edit landing before the keys and
+   * put back while the cycle ran settled to "the same", and the outputs
+   * stood built from bytes the tree no longer held. A write inside a
+   * command's window is judged by state as before: a task rewriting a file
+   * with the same bytes every run is no change, and so is a user's write
+   * there, which the run cannot tell from its own. Read when the event
+   * comes, not at the judgement: the edit's own time, before a revert
+   * stamps over it. The stamp runs up to a tick behind `Date.now()`, which
+   * dates the windows: a task's write was dated before its window opened,
+   * and every such write re-ran the loop, so the window widens by the racy
+   * window, as the hash memo judges a stamp.
+   */
+  sawEvent(abs: string): void {
+    const c = this.cycle
+    if (c === undefined) return
+    let t: number
+    try {
+      t = fs.lstatSync(abs).ctimeMs
+    } catch {
+      return
+    }
+    if (t < c.from || t > c.to) return
+    if (c.windows.writerDuring('', abs, t, t + racyWindowMs(t, FILE_HASH_RACY_MS)) !== undefined)
+      return
+    if (this.ctx.held() && !this.trackedAtArm(abs)) return
+    this.lastState.set(abs, UNSEEN)
+  }
+
+  /**
+   * The inputs a run read in a state no judgement saw (`TaskOutcome.driftedInput`):
+   * edited and put back while the task ran, a file settles to the state this
+   * loop last saw, and judged against it, the output built from the other
+   * state stood with no cycle after it. Each is a change at its next
+   * judgement; null (the input unnamed) makes every pending path one.
+   */
+  unseen(moved: readonly (string | null)[]): void {
+    for (const abs of moved)
+      for (const p of abs === null ? [...this.pending.keys()] : [abs]) this.lastState.set(p, UNSEEN)
+  }
+
   // A path this loop has never judged is a change only if it moved since
   // the watchers went live (its mtime or ctime, `modifiedBefore`). macOS delivers the initial run's own writes
   // AFTER the arm (CI, 2026-09-11: `app dist; re-running...` with no edit
@@ -178,17 +235,18 @@ export class ChangeJudge {
   // change: a deletion has no date to read.
   // 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),
-  // unless a nested repository holds it (`inNestedRepo`); 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.
+  // unless a nested repository holds it (`inNestedRepo`); it started a cycle with nothing changed. One born
+  // during a cycle where no command of it may write is a change all the
+  // same (`sawEvent`): the run may have read it. The blind spot left: one
+  // gone again before its event is read, which has no time to judge by.
+  // Git lists no ignored path, so one of those is a deletion as before.
   private sameState(abs: string, ignored: boolean, spell: (p: string) => string): boolean {
     const state = settledState(abs)
     const prev = this.lastState.get(abs)
     this.lastState.set(abs, state)
     if (prev !== undefined) return prev === state
-    // A new empty directory holds nothing a key reads, and the poller,
-    // sampling files, never reported one: a file made in it is the edit.
+    // A new empty directory holds nothing a key reads: a file made in it
+    // is the edit.
     // One a watch waits on (a project directory made again) is a change:
     // its cycle re-arms the project.
     if (state === EMPTY_DIR && isDirectory(abs) && this.ctx.awaited?.(abs) !== true) return true
@@ -241,6 +299,8 @@ export class ChangeJudge {
   }
 
   judge(): string | undefined {
+    // Before any state is read: a write after this is one the judgement may not have seen.
+    const at = this.ctx.clock?.() ?? Date.now()
     const ignored = gitIgnored(this.ctx.workspaceRoot, [...this.pending.keys()])
     const spell = gitSpeller(this.ctx.workspaceRoot)
     let first: string | undefined
@@ -260,12 +320,15 @@ export class ChangeJudge {
     // task rewrites every run, the loop the filter exists for) stays out,
     // as does one in a project nested under it, which it does not own.
     // So is one a task's inputs name outright (`.env.local`, `dist/**`).
+    // A write `sawEvent` found no command of the cycle could have made is
+    // the user's though it lies in the cycle: taken for the run's own, an
+    // edit to `node_modules/.gen/**` after its task ran never re-ran.
     const editForUncached = (p: string): boolean =>
       ([...this.ctx.uncached()].some(
         (dir) => p.startsWith(dir + path.sep) && this.ctx.fenced?.(dir, p) !== true,
       ) ||
         (this.ctx.namedIgnored?.() ?? []).some((n) => p === n || p.startsWith(n + path.sep))) &&
-      !this.writtenDuringLastCycle(p)
+      (this.lastState.get(p) === UNSEEN || !this.writtenDuringLastCycle(p))
     // A path still there names the cycle before a gone one: an editor or
     // `sed -i` saving through a temporary file fires that file first, and
     // the cycle was announced by a name already renamed away.
@@ -306,6 +369,7 @@ export class ChangeJudge {
     // read its write; resetting on either, the storm ran on unnamed (macOS
     // CI, 2026-10-29).
     if (firstAbs === undefined) return named
+    this.cycle = { from: at, to: Infinity, windows: commandWindows() }
     const byServer = this.ctx.held()
     if (!this.writtenDuringLastCycle(firstAbs, spell)) {
       this.streak.n = 0
@@ -319,7 +383,7 @@ export class ChangeJudge {
         'warn',
         byServer
           ? `vx watch: ${first} has started 3 cycles in a row, written while a server was running — a persistent task rewrites it. Add it to .gitignore (a git-ignored path never starts a cycle); until then every write starts a cycle.\n`
-          : `vx watch: ${first} has started 3 cycles in a row, written by the cycle before each — a task rewrites it every run. Declare it in cache.outputs (an output never starts a cycle) or add it to .gitignore (a git-ignored path never does); until then every run re-runs.\n`,
+          : `vx watch: ${first} has started 3 cycles in a row, written by the cycle before each — a task rewrites it every run. Declare it in outputs (an output never starts a cycle) or add it to .gitignore (a git-ignored path never does); until then every run re-runs.\n`,
         'out',
       )
     }

package/src/cli/watch-set.ts

@@ -26,8 +26,10 @@ import { type CliLoadOptions, loadCliProjects } from './workspace-config.js'
  * per-project arm watched the filter's answer only, so
  * `vx watch build --filter app` never re-ran on a `lib` edit that
  * `vx run build --filter app` would have rebuilt. A whole-workspace
- * scope is every project already and walks nothing. A config the loader
- * rejects contributes no edges here; the run that just happened said so.
+ * scope is every project already and walks nothing. When the edges cannot
+ * be read (a config the loader rejects, a dependency's directory removed)
+ * every project is watched: the scope alone dropped the dependencies a
+ * cycle runs, and nothing heard them again until a `vx lock`.
  */
 export async function watchedProjects(
   workspaceRoot: string,
@@ -37,14 +39,14 @@ export async function watchedProjects(
   staged: ReadonlyMap<string, ProjectEntry> | null = null,
 ): Promise<ProjectMeta[]> {
   if (scope.length === allProjects.length) return [...allProjects]
-  let edges: Map<string, string[]> | undefined
+  let edges: Map<string, string[]>
   try {
     edges =
       staged !== null
         ? taskEdgesFrom(staged)
         : (await taskEdges(workspaceRoot, allProjects, load)).edges
   } catch {
-    edges = undefined
+    return [...allProjects]
   }
   const graph = buildPackageGraph([...allProjects], edges)
   const names = new Set(scope.map((p) => p.name))
@@ -132,8 +134,8 @@ export async function sweepConfigs(
   }
   const foldTasks = (dir: string, config: ProjectConfig, names: Set<string> | null): void => {
     for (const [name, task] of Object.entries(config.tasks ?? {})) {
-      add(dir, task.cache?.outputs?.files)
-      add(workspaceRoot, task.cache?.outputs?.workspaceFiles)
+      add(dir, task.outputs?.files)
+      add(workspaceRoot, task.outputs?.workspaceFiles)
       if (names !== null && !names.has(name)) continue
       if (
         task.inputs === undefined &&
@@ -147,8 +149,8 @@ export async function sweepConfigs(
         for (const rel of named.workspaceFiles) namedIgnored.add(path.join(workspaceRoot, rel))
       }
       for (const g of task.inputs?.workspaceFiles ?? []) workspaceInputs.add(g)
-      addInputs(dir, task.inputs?.files, task.cache?.outputs?.files)
-      addInputs(workspaceRoot, task.inputs?.workspaceFiles, task.cache?.outputs?.workspaceFiles)
+      addInputs(dir, task.inputs?.files, task.outputs?.files)
+      addInputs(workspaceRoot, task.inputs?.workspaceFiles, task.outputs?.workspaceFiles)
     }
   }
   const result = (staged: Map<string, ProjectEntry> | null): ConfigSweep => ({