@vzn/vx 0.0.361 → 0.0.362

package/package.json

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

package/src/cache/cache.ts

@@ -1590,8 +1590,24 @@ export class Cache implements CacheLayer {
     // whole. A commit that fails after the rename takes the artifact back
     // out: the old rows then name no artifact, which a probe reads as a
     // miss.
+    //
+    // A previous artifact is moved aside first, never renamed over: ext4
+    // flushes the incoming file's delayed blocks when a rename replaces a
+    // file, 0.55 ms against 0.04 on the main thread with the write lock
+    // held (a `--force` run, 2026-10-02). A reader probing between the two
+    // renames finds no artifact, a miss (`ArtifactVanishedError`); one
+    // holding the old file still reads it whole. The aside name is a temp
+    // name, so a crash before its unlink leaves an orphan the sweep takes.
+    const aside = this.tempPath(hash)
+    let displaced = false
     let renamed = false
     const tx = this.db.transaction(() => {
+      try {
+        renameSync(finalPath, aside)
+        displaced = true
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
+      }
       renameSync(tmpPath, finalPath)
       renamed = true
       insertEntry.run(
@@ -1628,11 +1644,13 @@ export class Cache implements CacheLayer {
     try {
       tx.immediate()
     } catch (err) {
+      endTx()
       await unlink(renamed ? finalPath : tmpPath).catch(() => undefined)
+      if (displaced) await unlink(aside).catch(() => undefined)
       throw err
-    } finally {
-      endTx()
     }
+    endTx()
+    if (displaced) await unlink(aside).catch(() => undefined)
   }
 
   /** Apply the deferred accessed_at bumps in one statement. */

package/src/graph/scheduler.ts

@@ -181,6 +181,14 @@ export interface ScheduleOptions {
    *     be the next clean run's stale hit (`ExecuteArgs.taintedUpstream`).
    */
   continueMode?: ContinueMode
+  /**
+   * A failure the graph's outcomes do not hold yet: a persistent task
+   * that died after it became ready. Its outcome said `success` when it
+   * was ready, so this is how a dependant not yet started learns of it:
+   * under 'deps-ok' it is skipped as below a failed task, and under
+   * 'never' it stops dispatch.
+   */
+  serverDied?: (id: string) => boolean
   execute: (node: TaskNode, upstream: TaskOutcome[]) => Promise<TaskOutcome>
   onStart?: (node: TaskNode) => void
   onFinish?: (outcome: TaskOutcome) => void
@@ -563,8 +571,19 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
     // they're dep-independent, so they typically restore before a dep
     // could fail anyway.
     const aborted = (): boolean => options.signal?.aborted === true
+    const serverDied = options.serverDied ?? ((): boolean => false)
+    const servers =
+      options.serverDied === undefined
+        ? []
+        : [...nodes.values()]
+            .filter((n) => n.config.exec?.persistent !== undefined)
+            .map((n) => n.id)
     const willSkip = (id: string): boolean => {
       if (failFastTripped || aborted()) return true
+      if (continueMode === 'never' && servers.some(serverDied)) {
+        failFastTripped = true
+        return true
+      }
       if (inRestoreTier(id)) return false
       if (continueMode === 'always') return false
       const node = nodes.get(id) as TaskNode
@@ -580,7 +599,8 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
           u?.status === 'failed' ||
           u?.status === 'skipped' ||
           u?.status === 'aborted' ||
-          blockedRestores.has(d)
+          blockedRestores.has(d) ||
+          serverDied(d)
         )
       })
     }
@@ -651,6 +671,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
           const viaRestore = node.deps.find((d) => blockedRestores.has(d))
           const blockedBy =
             blocker?.node.id ??
+            node.deps.find(serverDied) ??
             viaSkip?.blockedBy ??
             (viaRestore === undefined ? undefined : blockedRestores.get(viaRestore))
           finishOne(id, {

package/src/orchestrator/execute-task.ts

@@ -821,7 +821,15 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       })
       .catch(async (raw: unknown) => {
         const err = nameExecutorFailure(args.executor, raw)
-        const message = err instanceof Error ? err.message : String(err)
+        // A remote executor's message carries the server's own text, which
+        // may echo the env it was sent: masked here, where it is printed,
+        // and on the error the scheduler prints with its cause (L-39).
+        if (secrets !== null) {
+          for (const e of [err, err instanceof Error ? err.cause : undefined])
+            if (e instanceof Error) e.message = secrets.mask(e.message)
+        }
+        const message =
+          err instanceof Error ? err.message : (secrets?.mask(String(err)) ?? String(err))
         log.taskStderr(node, `${message}\n`)
         await sweepPlaceholders(placeholders)
         throw err

package/src/orchestrator/run.ts

@@ -922,6 +922,12 @@ async function runOnBus(
       ...(hasPooledExecutor(executors) ? { poolOf: poolOfPlacement(placements) } : {}),
       ...(admit !== undefined ? { admit } : {}),
       ...(options.continueMode !== undefined ? { continueMode: options.continueMode } : {}),
+      // A server that ended on its own is failed (the end of the run says
+      // so); what has not yet started hears it before it dispatches (C-88).
+      serverDied: (id) => {
+        const child = persistentRegistry.get(id)
+        return child !== undefined && hasEnded(child) && child.exitCode !== 0
+      },
       signal: stopRun.signal,
       onStart: (node) => {
         log.taskStart?.(node)

package/src/workspace/migrate-scripts.ts

@@ -296,7 +296,7 @@ function servesCommand(command: string): boolean {
 /**
  * Whether script `name` never exits: by name, as a watcher, as a server, or
  * running such a script of its own package by name (docusaurus's
- * `start:baseUrl`: `cross-env BASE_URL=… pnpm start`).
+ * `start:baseUrl`: `cross-env BASE_URL=… pnpm start`) or through a runner.
  */
 function isPersistent(
   name: string,
@@ -307,8 +307,13 @@ function isPersistent(
   if (typeof own !== 'string' || seen.has(name)) return false
   seen.add(name)
   if (PERSISTENT_TASK_NAMES.has(name) || isWatcher(name, own) || servesCommand(own)) return true
+  // Through a runner too: `concurrently "npm:web" "npm:api"` and `run-p web
+  // api` over two servers mapped as one-shot tasks (D-113).
+  const text = Object.entries(scripts).filter(
+    (e): e is [string, string] => typeof e[1] === 'string',
+  )
   return foreground(own).some((segment) =>
-    [...segment.matchAll(RUNS_SCRIPT)].some((m) => isPersistent(m[1]!, scripts, seen)),
+    scriptRefs(segment, text).some((ref) => isPersistent(ref, scripts, seen)),
   )
 }