@vzn/vx 0.0.245 → 0.0.247

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.245",
+  "version": "0.0.247",
   "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.245",
-    "@vzn/vx-linux-arm64": "0.0.245",
-    "@vzn/vx-darwin-x64": "0.0.245",
-    "@vzn/vx-darwin-arm64": "0.0.245"
+    "@vzn/vx-linux-x64": "0.0.247",
+    "@vzn/vx-linux-arm64": "0.0.247",
+    "@vzn/vx-darwin-x64": "0.0.247",
+    "@vzn/vx-darwin-arm64": "0.0.247"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/inputs.ts

@@ -29,6 +29,7 @@ import {
   shellArgv,
   splitNegations,
   slashBraceExpansions,
+  staticPrefix,
   taskGlob,
   UserError,
 } from '../util/index.js'
@@ -615,13 +616,25 @@ export async function cleanOutputs(args: {
   projectDir: string
   outputs: string[]
   nestedProjectDirs: string[]
+  /**
+   * Before a miss: keep the directory each wildcard glob is rooted at
+   * (`dist` for `dist/**`). The task writes its matches under it, so a
+   * remove there bought only an rmdir and the task's mkdir: 0.4 ms of a
+   * 4.9 ms one-file miss (B-49). A restore prunes it, since the entry's
+   * shape decides there.
+   */
+  keepGlobRoots?: boolean
 }): Promise<string[]> {
   const files = await resolveOutputs(args)
   // `force: true` makes rm tolerate ENOENT (e.g. when two output
   // globs overlap and a sibling already deleted a path mid-iteration).
   // A symlink is unlinked, never followed.
   await removeAll(files, args.projectDir)
-  await pruneEmptiedDirs(args.projectDir, files)
+  await pruneEmptiedDirs(
+    args.projectDir,
+    files,
+    args.keepGlobRoots === true ? globRoots(args.projectDir, args.outputs) : undefined,
+  )
   // Project-relative posix paths of what was removed — the caller
   // feeds these to GitFilesCache.markOutputsChanged after a restore.
   return files.map((f) => path.relative(args.projectDir, f).split(path.sep).join('/'))
@@ -778,7 +791,11 @@ async function removeAll(files: readonly string[], root: string): Promise<void>
  * holds something — a stray the globs do not cover — stays, and the restore
  * says so if it is in the way.
  */
-async function pruneEmptiedDirs(root: string, removed: readonly string[]): Promise<void> {
+async function pruneEmptiedDirs(
+  root: string,
+  removed: readonly string[],
+  keep?: ReadonlySet<string>,
+): Promise<void> {
   const rootResolved = path.resolve(root)
   // LEVEL ORDER, not a walk-up per directory. A parent is attempted only
   // once every one of its children has had its turn, which is what makes
@@ -794,7 +811,8 @@ async function pruneEmptiedDirs(root: string, removed: readonly string[]): Promi
   while (level.size > 0) {
     const parents = new Set<string>()
     const dirs = [...level].filter(
-      (dir) => dir !== rootResolved && dir.startsWith(rootResolved + path.sep),
+      (dir) =>
+        dir !== rootResolved && dir.startsWith(rootResolved + path.sep) && keep?.has(dir) !== true,
     )
     const gone = (err: NodeJS.ErrnoException): boolean => err.code === 'ENOENT'
     if (dirs.length <= SYNC_CLEAN_MAX) {
@@ -817,6 +835,21 @@ async function pruneEmptiedDirs(root: string, removed: readonly string[]): Promi
   }
 }
 
+/**
+ * The directories the wildcard output globs are rooted at, absolute. A
+ * literal names a file or a tree whose shape the task decides, so it has
+ * none; nor has a glob rooted at the project itself.
+ */
+function globRoots(projectDir: string, outputs: readonly string[]): Set<string> {
+  const roots = new Set<string>()
+  for (const g of outputs) {
+    if (g.startsWith('!') || isLiteralPattern(g)) continue
+    const prefix = staticPrefix(g)
+    if (prefix !== '.') roots.add(path.resolve(projectDir, prefix))
+  }
+  return roots
+}
+
 /**
  * Resolve declared `outputs.workspaceFiles` globs (workspace-root-
  * relative) to actual produced files. Live-FS glob like

package/src/cli/watch-fs.ts

@@ -153,6 +153,7 @@ export function armWatcher(
   timeoutMs = WATCH_PROBE_TIMEOUT_MS,
 ): ArmedWatcher {
   let markReady: (ok: boolean) => void = () => {}
+  let arrived = false
   const seen = new Promise<boolean>((resolve) => {
     markReady = resolve
   })
@@ -163,6 +164,7 @@ export function armWatcher(
     // can see; the write's own event names the file.
     if (filename === '' || filename === '.') return
     if (filename === WATCH_PROBE) {
+      arrived = true
       markReady(true)
       return
     }
@@ -191,7 +193,14 @@ export function armWatcher(
         break // an unwritable dir gets no proof; the watcher is kept
       }
       const remaining = deadline - Date.now()
-      if (remaining <= 0) break
+      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
+        // an event already queued in before giving up on it.
+        await new Promise((resolve) => setTimeout(resolve, 0))
+        ok = arrived
+        break
+      }
       const pause = new Promise<boolean>((resolve) => {
         setTimeout(() => resolve(false), Math.min(step, remaining)).unref()
       })

package/src/orchestrator/execute-task.ts

@@ -758,7 +758,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       // re-create would stay in a same-project consumer's input set, keeping
       // that consumer's key unchanged while the file is gone from disk.
       const endClean = span('miss: clean outputs')
-      const cleanedRels = await cleanOutputs(cleanArgs)
+      const cleanedRels = await cleanOutputs({ ...cleanArgs, keepGlobRoots: true })
       endClean()
       args.gitFilesCache?.noteClean(node.id, node.projectDir, cleanedRels)
       args.gitFilesCache?.markOutputsChanged(node.projectDir, cleanedRels)