@vzn/vx 0.0.374 → 0.0.375

package/package.json

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

package/src/graph/index.ts

@@ -10,6 +10,7 @@ export {
 } from './dependency-spec.js'
 export {
   type ContinueMode,
+  deadServerBehind,
   RestoreDemoted,
   runGraph,
   type TaskOutcome,

package/src/graph/scheduler.ts

@@ -338,6 +338,26 @@ class ReadyHeap {
   }
 }
 
+/**
+ * The dead server a dependency stands for: itself, or one a group reaches.
+ * A group is a name for its deps, and it finished the moment the server
+ * was ready, so a task behind it ran against the dead one.
+ */
+export function deadServerBehind(
+  nodes: ReadonlyMap<string, TaskNode>,
+  serverDied: (id: string) => boolean,
+  id: string,
+): string | undefined {
+  if (serverDied(id)) return id
+  const n = nodes.get(id)
+  if (n === undefined || !isGroupTask(n)) return undefined
+  for (const d of n.deps) {
+    const dead = deadServerBehind(nodes, serverDied, d)
+    if (dead !== undefined) return dead
+  }
+  return undefined
+}
+
 /**
  * Run the task graph. Independent tasks run in parallel up to `concurrency`.
  * If a task fails, its dependents are marked `skipped` but unrelated tasks
@@ -572,19 +592,8 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
     // could fail anyway.
     const aborted = (): boolean => options.signal?.aborted === true
     const serverDied = options.serverDied ?? ((): boolean => false)
-    // The dead server a dependency stands for: itself, or one a group
-    // reaches. A group is a name for its deps, and it finished the moment
-    // the server was ready, so a task behind it ran against the dead one.
-    const deadServerVia = (id: string): string | undefined => {
-      if (serverDied(id)) return id
-      const n = nodes.get(id)
-      if (n === undefined || !isGroupTask(n)) return undefined
-      for (const d of n.deps) {
-        const dead = deadServerVia(d)
-        if (dead !== undefined) return dead
-      }
-      return undefined
-    }
+    const deadServerVia = (id: string): string | undefined =>
+      deadServerBehind(nodes, serverDied, id)
     const servers =
       options.serverDied === undefined
         ? []

package/src/orchestrator/run.ts

@@ -22,6 +22,7 @@ import { DeferredOutputs } from './deferred-outputs.js'
 import { resolveDownloadModes } from './download-policy.js'
 import type { TaskExecutor } from '../exec/index.js'
 import {
+  deadServerBehind,
   isGroupTask,
   markSurfacedDeps,
   runGraph,
@@ -873,12 +874,28 @@ async function runOnBus(
         `[vx] --exclude-dependencies: ${excluded.unsaved} cached task(s) build on a skipped dependency; what they build is not saved`,
       )
     }
-    const taint = taintTracker(options.continueMode === 'always', excluded.seeds, nodes)
+    // 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).
+    const serverDied = (id: string): boolean => {
+      const child = persistentRegistry.get(id)
+      return child !== undefined && hasEnded(child) && child.exitCode !== 0
+    }
+    // Under `always` a task that starts while a server it depends on is
+    // dead runs on a failure the outcomes do not hold yet (the server's
+    // says `success` until the run ends), so it is seeded here, at its
+    // dispatch, and the tracker carries it to what is built on it.
+    const taintSeeds = new Set(excluded.seeds)
+    const taint = taintTracker(options.continueMode === 'always', taintSeeds, nodes)
     const dependedOn = new Set<string>()
     for (const n of nodes.values()) for (const d of n.deps) dependedOn.add(d)
 
     const buildExecuteArgs = (node: TaskNode, upstream: TaskOutcome[], reuseProbe = true) => {
       const probe = reuseProbe ? shortCircuit.preProbed.get(node.id) : undefined
+      if (
+        options.continueMode === 'always' &&
+        node.deps.some((d) => deadServerBehind(nodes, serverDied, d) !== undefined)
+      )
+        taintSeeds.add(node.id)
       const tainted = taint.judge(node, upstream)
       return {
         node,
@@ -940,12 +957,7 @@ 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
-      },
+      serverDied,
       signal: stopRun.signal,
       onStart: (node) => {
         log.taskStart?.(node)