@vzn/vx 0.0.600 → 0.0.602

package/package.json

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

package/src/exec/runner.ts

@@ -867,8 +867,8 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
   // Wire up readers. We deliberately don't await them — they run for
   // the child's lifetime. The `ready` promise resolves out-of-band.
   const [stdout, stderr] = pipes.streams(child)
-  void Promise.all([consumeChunks(stdout, false), consumeChunks(stderr, true)]).finally(() =>
-    pipes.close(),
+  const readers = Promise.all([consumeChunks(stdout, false), consumeChunks(stderr, true)]).finally(
+    () => pipes.close(),
   )
 
   opts.liveChildren?.add(child)
@@ -915,10 +915,19 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
 
   // If the child exits BEFORE ready fires, that's a failure to start
   // — reject the ready promise so the caller can surface it.
-  void child.exited.then((code) => {
+  void child.exited.then(async (code) => {
     opts.liveChildren?.delete(child)
     releaseServerGroup(child)
     if (readyTimer !== undefined) clearTimeout(readyTimer)
+    // The exit can land before the readers took the marker it printed on
+    // the way out: `echo READY; exit` read as never ready under load. The
+    // drain is bounded, as a task's is, for a grandchild holding the pipe.
+    if (readyAt === undefined && gaveUpAt === undefined) {
+      await Promise.race([
+        readers,
+        new Promise((resolve) => setTimeout(resolve, POST_EXIT_DRAIN_MS).unref?.()),
+      ])
+    }
     if (readyAt === undefined && gaveUpAt === undefined) {
       rejectReady(
         new PersistentReadyError(

package/src/graph/task-graph.ts

@@ -1389,7 +1389,7 @@ interface Side {
   node: TaskNode
   globs: readonly string[]
   reads: boolean
-  /** The project's root-relative dir for a rebased `files` output. */
+  /** The project's root-relative dir for rebased `files` globs. */
   rel?: string
 }
 
@@ -1407,7 +1407,9 @@ interface Side {
  * scope mirrors `detectOutputCollisions`: `inputs.files` against another
  * same-project task's `outputs.files`; root-anchored `inputs.workspaceFiles`
  * against every other task's `outputs.workspaceFiles` and, with the root
- * known, its `outputs.files` rebased to the root. A task's own outputs are
+ * known, its `outputs.files` rebased to the root; and, with the root known,
+ * `inputs.files` rebased to the root against another task's
+ * `outputs.workspaceFiles`, which may land in any project (X-135). A task's own outputs are
  * already subtracted from its inputs, and an output the reader's `!` entries
  * take back whole is no overlap. A keyed group is exempt: the default
  * `build` reads `**` of a config-less dependency and runs nothing, and its
@@ -1416,6 +1418,8 @@ interface Side {
 function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: string): void {
   const byProject = new Map<string, Side[]>()
   const rooted: Side[] = []
+  const wsWriters: Side[] = []
+  const filesReaders: TaskNode[] = []
   const filesWriters: TaskNode[] = []
   let projectReaders = false
   let rootReaders = false
@@ -1433,12 +1437,17 @@ function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: strin
       bucket(n.projectName).push({ node: n, globs: outFiles, reads: false })
       filesWriters.push(n)
     }
-    if (outWs.length > 0) rooted.push({ node: n, globs: outWs, reads: false })
+    if (outWs.length > 0) {
+      const side = { node: n, globs: outWs, reads: false }
+      rooted.push(side)
+      wsWriters.push(side)
+    }
     if (isGroupTask(n)) continue
     const inFiles = splitNegations(cache.inputs.files).positive
     const inWs = splitNegations(cache.inputs.workspaceFiles ?? []).positive
     if (inFiles.length > 0) {
       bucket(n.projectName).push({ node: n, globs: inFiles, reads: true })
+      filesReaders.push(n)
       projectReaders = true
     }
     if (inWs.length > 0) {
@@ -1458,6 +1467,23 @@ function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: strin
       }
     }
   }
+  if (projectReaders && wsWriters.length > 0 && workspaceRoot !== undefined) {
+    const sides = [...wsWriters]
+    for (const node of filesReaders) {
+      const rel = relPosix(workspaceRoot, node.projectDir)
+      const globs = splitNegations(node.config.cache!.inputs.files).positive.map((g) =>
+        rel === '' ? g : `${rel}/${g}`,
+      )
+      sides.push({ node, globs, reads: true, rel })
+    }
+    for (const [i, j] of overlapCandidates(
+      sides,
+      (s) => s.globs,
+      (s) => s.reads,
+    )) {
+      readsOutputs(sides[i]!, sides[j]!, 'files')
+    }
+  }
   if (!rootReaders) return
   if (workspaceRoot !== undefined) {
     for (const node of filesWriters) {
@@ -1481,6 +1507,8 @@ function readsOutputs(x: Side, y: Side, field: 'files' | 'workspaceFiles'): void
   if (x.reads === y.reads || x.node === y.node) return
   const [reader, writer] = x.reads ? [x, y] : [y, x]
   const cache = reader.node.config.cache!
+  // A reader rebased to the root (X-135) speaks in its project's terms.
+  const at = reader.rel === undefined || reader.rel === '' ? '' : `${reader.rel}/`
   // What the reader's key never reads: its `!` entries and its own outputs.
   const takeBack = [
     ...splitNegations(field === 'files' ? cache.inputs.files : (cache.inputs.workspaceFiles ?? []))
@@ -1488,18 +1516,19 @@ function readsOutputs(x: Side, y: Side, field: 'files' | 'workspaceFiles'): void
     ...splitNegations(
       field === 'files' ? cache.outputs.files : (cache.outputs.workspaceFiles ?? []),
     ).positive,
-  ]
+  ].map((g) => at + g)
   for (const go of writer.globs) {
     if (outputTakenBack(go, takeBack)) continue
     for (const gi of reader.globs) {
       if (!outputsOverlap(gi, go)) continue
       const shown =
         writer.rel === undefined || writer.rel === '' ? go : go.slice(writer.rel.length + 1)
+      const out = at !== '' && go.startsWith(at) ? go.slice(at.length) : go
       throw new UserError(
-        `${reader.node.id} reads ${JSON.stringify(gi)} in cache.inputs.${field}, which matches ` +
+        `${reader.node.id} reads ${JSON.stringify(gi.slice(at.length))} in cache.inputs.${field}, which matches ` +
           `${writer.node.id}'s output ${JSON.stringify(shown)} — a task's key must not read ` +
           `another task's outputs (the dependency's key already cascades through dependsOn). ` +
-          `Exclude it: add ${JSON.stringify(`!${go}`)} to ${reader.node.id}'s ` +
+          `Exclude it: add ${JSON.stringify(`!${out}`)} to ${reader.node.id}'s ` +
           `cache.inputs.${field}, or set rules: { upfrontKeys: false } in vx.workspace.ts to ` +
           `let it wait for its producer.`,
       )

package/src/orchestrator/failure-mode.ts

@@ -22,10 +22,13 @@ export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
 /**
  * Per-key outcome projection: every keyed (project, task, hash) under
  * `source` (`runs`, or a relation with its `id`, `project`, `task`, `hash`,
- * `status`, `cache_hit` columns) with how often it failed, how often it
+ * `status`, `cache_hit`, `cached` columns) with how often it failed, how often it
  * passed — an executed success or a cache hit, which replays a success —
- * and how often it failed AFTER its first pass (`relapses`). Every
- * flakiness reader is a filter over this one projection.
+ * and how often it failed AFTER its first pass (`relapses`). A task with
+ * no cache block keys on its config alone and runs every time, so its key
+ * says nothing about its inputs: no reader counts it, as no run's row
+ * calls it flaky. Every flakiness reader is a filter over this one
+ * projection.
  */
 function keyOutcomesSql(source: string, where = ''): string {
   return `SELECT project, task, hash, SUM(failed) AS failures, SUM(passed) AS passes,
@@ -39,7 +42,7 @@ function keyOutcomesSql(source: string, where = ''): string {
              CASE WHEN status = 'success' OR status IN ${HIT_STATUSES} OR cache_hit = 1
                THEN 1 ELSE 0 END AS passed
            FROM ${source}
-           WHERE ${KEYED_RUNS_SQL}${where}))
+           WHERE ${KEYED_RUNS_SQL} AND cached IS NOT 0${where}))
        GROUP BY project, task, hash`
 }
 

package/src/orchestrator/run-records.ts

@@ -14,6 +14,8 @@ import { isCacheHit, taskTelemetryOf, type TaskTelemetry } from './telemetry.js'
 
 export interface RunRecordsInput {
   outcomes: readonly TaskOutcome[]
+  /** Tasks that ran behind a failed dependency (`--continue=always`). */
+  tainted?: ReadonlySet<string>
   runId: string
   /** Wall-clock ms at run start; every per-task ns offset is anchored to it. */
   startedAtMs: number
@@ -66,7 +68,11 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
     if (o.status === 'aborted') continue
     if (input.withTelemetry) telemetryTasks.push(taskTelemetryOf(o))
     runs.push({
-      ...(o.hash !== undefined ? { hash: o.hash } : {}),
+      // A failure behind a failed dependency is recorded keyless (`''`, which
+      // the key readers skip): the flaky list asks a key whether it failed.
+      ...(o.hash !== undefined && !(o.status === 'failed' && input.tainted?.has(o.node.id) === true)
+        ? { hash: o.hash }
+        : {}),
       project: o.node.projectName,
       task: o.node.taskName,
       status: o.status,

package/src/orchestrator/run.ts

@@ -939,6 +939,7 @@ async function runOnBus(
     // 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 taintedRan = new Set<string>()
     const dependedOn = new Set<string>()
     for (const n of nodes.values()) for (const d of n.deps) dependedOn.add(d)
 
@@ -959,6 +960,7 @@ async function runOnBus(
       )
         taintSeeds.add(node.id)
       const tainted = taint.judge(node, upstream)
+      if (tainted) taintedRan.add(node.id)
       return {
         node,
         upstream,
@@ -1027,7 +1029,7 @@ async function runOnBus(
     const historyDb = prepared.localCache.dbHandle()
     const cacheOff = cachesNothing(policy)
     const judgeFlaky = (o: TaskOutcome): void => {
-      const candidates = flakyCandidates([o])
+      const candidates = flakyCandidates([o], taintedRan)
       if (candidates.length === 0) return
       try {
         const found = detectFlaky(historyDb, candidates)[0]
@@ -1212,6 +1214,7 @@ async function runOnBus(
     const recordsOf = (final: TaskOutcome[], runOk: boolean) =>
       assembleRunRecords({
         outcomes: final,
+        tainted: taintedRan,
         runId,
         startedAtMs: endedAtMsAtStart,
         endedAtMs,
@@ -1759,7 +1762,10 @@ export function projectNamed(
 }
 
 /** The executed, keyed outcomes of a run — what flakiness is judged on. */
-function flakyCandidates(outcomes: readonly TaskOutcome[]): FlakyCandidate[] {
+function flakyCandidates(
+  outcomes: readonly TaskOutcome[],
+  tainted: ReadonlySet<string>,
+): FlakyCandidate[] {
   const out: FlakyCandidate[] = []
   for (const o of outcomes) {
     if (o.status !== 'success' && o.status !== 'failed') continue
@@ -1768,6 +1774,9 @@ function flakyCandidates(outcomes: readonly TaskOutcome[]): FlakyCandidate[] {
     // and runs every time, so one bad network day would read as a flake for
     // thirty days. Groups do no work.
     if (o.hash === undefined || o.node.config.cache === undefined || isGroupTask(o.node)) continue
+    // Behind a failed dependency the failure is the dependency's: the key it
+    // had passed on read as a flake for thirty days.
+    if (o.status === 'failed' && tainted.has(o.node.id)) continue
     out.push({
       project: o.node.projectName,
       task: o.node.taskName,